mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/ops/operations/array_ops.py

@@ -29,6 +29,7 @@ from mindspore.common._utils import is_shape_unknown, is_dim_unknown
 from mindspore.ops.primitive import Primitive, PrimitiveWithInfer, PrimitiveWithCheck, prim_attr_register, _run_op
 from mindspore import _checkparam as validator
 from mindspore._checkparam import _check_3d_int_or_tuple
+from mindspore.ops._tracefunc import PackFunc
 from mindspore.common import dtype as mstype
 from mindspore.common._decorator import deprecated
 from mindspore.common.parameter import Parameter
@@ -174,27 +175,11 @@ def _check_infer_attr_reduce(axis, keep_dims, prim_name):
 
 class Expand(Primitive):
     """
-    Expands the Tensor along singleton dimensions(dim with size 1) to match given desired shape.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Refer to :func:`mindspore.ops.expand` for more details.
-
-    Supported Platforms:
-        ``Ascend`` ``CPU``
-
-    Examples:
-        >>> x = Tensor(np.array([[1], [2], [3]]), mindspore.float32)
-        >>> shape = Tensor(np.array([3,4]), mindspore.int32)
-        >>> expand = ops.Expand()
-        >>> y = expand(x, shape)
-        >>> print(y)
-        [[1. 1. 1. 1.]
-         [2. 2. 2. 2.]
-         [3. 3. 3. 3.]]
+    :class:`mindspore.ops.Expand` will be deprecated in the future.
+    Please use :class:`mindspore.ops.BroadcastTo` instead.
     """
 
+    @deprecated("2.1", "BroadcastTo", False)
     @prim_attr_register
     def __init__(self):
         """Initialize Expand."""
@@ -204,14 +189,28 @@ class Expand(Primitive):
 
 class ExpandDims(PrimitiveWithCheck):
     """
-    Adds an additional dimension to `input_x` at the given axis.
+    Adds an additional dimension to `input_x` at the given axis, the dimension of
+    `input_x` should be greater than or equal to 1.
 
     Refer to :func:`mindspore.ops.expand_dims` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        - **axis** (int) - Specifies the dimension index at which to expand
+          the shape of `input_x`. The value of axis must be in the range
+          `[-input_x.ndim-1, input_x.ndim]`. Only constant value is allowed.
+
+    Outputs:
+        Tensor, the shape of tensor is :math:`(1, x_1, x_2, ..., x_R)` if the
+        value of `axis` is 0. It has the same data type as `input_x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
         >>> expand_dims = ops.ExpandDims()
         >>> output = expand_dims(input_tensor, 0)
@@ -249,6 +248,9 @@ class DType(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
         >>> output = ops.DType()(input_tensor)
         >>> print(output)
@@ -302,6 +304,10 @@ class Cast(PrimitiveWithCheck):
     """
     Returns a tensor with the new specified data type.
 
+    Note:
+        When converting complex numbers to boolean type, the imaginary part of the complex number is not
+        taken into account. As long as the real part is non-zero, it returns True; otherwise, it returns False.
+
     Inputs:
         - **input_x** (Union[Tensor, Number]) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
           The tensor to be cast.
@@ -318,6 +324,9 @@ class Cast(PrimitiveWithCheck):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_np = np.random.randn(2, 3, 4, 5).astype(np.float32)
         >>> input_x = Tensor(input_np)
         >>> type_dst = mindspore.int32
@@ -340,7 +349,7 @@ class Cast(PrimitiveWithCheck):
                 data = x.data
                 if data.dtype == dtype:
                     return (True, x)
-            if isinstance(x, Tensor) and x.dtype == dtype:
+            if isinstance(x, Tensor) and x.dtype == dtype and not PackFunc.is_tracing():
                 x = Tensor(x)
                 x.set_cast_dtype()
                 return (True, x)
@@ -353,20 +362,20 @@ class Cast(PrimitiveWithCheck):
             return None
         src_type = mstype.get_py_obj_dtype(x)
         validator.check_subclass("input_x", src_type,
-                                 [mstype.tensor, mstype.number], self.name)
+                                 [mstype.tensor_type, mstype.number], self.name)
         validator.check_subclass("type", dst_type, mstype.number, self.name)
 
-        if isinstance(src_type, type(mstype.tensor)):
+        if isinstance(src_type, type(mstype.tensor_type)):
             src_type = src_type.element_type()
-        if isinstance(dst_type, type(mstype.tensor)):
+        if isinstance(dst_type, type(mstype.tensor_type)):
             dst_type = dst_type.element_type()
 
         value = None
         np_dst_type = mstype.dtype_to_nptype(dst_type)
         if isinstance(x, (int, float)):
-            value = Tensor(np.array(x).astype(np_dst_type))
+            value = Tensor(np.array(x).astype(np_dst_type), dtype=dst_type)
         else:
-            value = Tensor(x.asnumpy().astype(np_dst_type))
+            value = Tensor(x.asnumpy().astype(np_dst_type), dtype=dst_type)
         return value
 
 
@@ -402,15 +411,19 @@ class Im2Col(Primitive):
     Note:
         Currently, only 4-D input tensors (batched image-like tensors) are supported.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Args:
         ksizes (Union[int, tuple[int], list[int]]): The size of the kernel, should be two int
             for height and width. If type is int, it means that height equal with width. Must be specified.
         strides (Union[int, tuple[int], list[int]], optional): The stride of the window, should be two int
-            for height and width. If type is int, it means that height equal with width. Default: 1.
+            for height and width. If type is int, it means that height equal with width. Default: ``1`` .
         dilations (Union[int, tuple[int], list[int]], optional): The dilation of the window, should be two int
-            for height and width. If type is int, it means that height equal with width. Default: 1.
+            for height and width. If type is int, it means that height equal with width. Default: ``1`` .
+
         pads (Union[int, tuple[int], list[int]], optional): The pad of the window, that must be a tuple of
-            one or two `int` for height and width. Default: 0.
+            one or two `int` for height and width. Default: ``0`` .
 
             - If one int, :math:`pad\_height = pad\_width`.
             - If two int, :math:`pad\_height = pads[0]`, :math:`pad\_width = pads[1]`.
@@ -418,7 +431,6 @@ class Im2Col(Primitive):
 
     Inputs:
         - **x** (Tensor) - input tensor, only 4-D input tensors (batched image-like tensors) are supported.
-          support all real number data type.
 
     Outputs:
         Tensor, a 4-D Tensor with same type of input `x`.
@@ -437,6 +449,9 @@ class Im2Col(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> x = Tensor(input_data=np.random.rand(4, 4, 32, 32), dtype=mstype.float64)
         >>> im2col = ops.Im2Col(ksizes=3, strides=1, dilations=1)
         >>> y = im2col(x)
@@ -503,15 +518,15 @@ class Col2Im(Primitive):
         kernel_size (Union[int, tuple[int], list[int]]): The size of the kernel, should be two positive int
             for height and width. If type is int, it means that height equal with width. Must be specified.
         dilation (Union[int, tuple[int], list[int]], optional): The size of the dilation, should be two positive int
-            for height and width. If type is int, it means that height equal with width. Default: 1.
+            for height and width. If type is int, it means that height equal with width. Default: ``1`` .
         padding (Union[int, tuple[int], list[int]], optional): The size of the padding, should be two int
-            for height and width. If type is int, it means that height equal with width. Default: 0.
+            for height and width. If type is int, it means that height equal with width. Default: ``0`` .
         stride (Union[int, tuple[int], list[int]], optional): The size of the stride, should be two positive int
-            for height and width. If type is int, it means that height equal with width. Default: 1.
+            for height and width. If type is int, it means that height equal with width. Default: ``1`` .
 
     Inputs:
-        - **x** (Tensor) - 4D tensor with data type float16 or float32.
-        - **output_size** (Tensor) - 1D tensor with 2 elements of data type int32.
+        - **x** (Tensor) - 4D input Tensor.
+        - **output_size** (Tensor) - 1D tensor with 2 elements of data type int32 or int64.
 
     Outputs:
         Tensor, a 4-D Tensor with same type of input `x`.
@@ -574,10 +589,21 @@ class Reshape(PrimitiveWithCheck):
 
     Refer to :func:`mindspore.ops.reshape` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        - **input_shape** (tuple[int]) - The input tuple is constructed by multiple
+          integers, i.e., :math:`(y_1, y_2, ..., y_S)`.
+
+    Outputs:
+        Tensor, the shape of tensor is :math:`(y_1, y_2, ..., y_S)`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
         >>> reshape = ops.Reshape()
         >>> output = reshape(input_x, (3, 2))
@@ -597,8 +623,9 @@ class Reshape(PrimitiveWithCheck):
         # for shape is not constant
         if shape is None or self.none_in_tuple_or_list(shape) or x is None:
             return None
+
         if isinstance(shape, (Tensor, Tensor_)):
-            validator.check_tensor_dtype_valid("shape", mstype.tensor_type(shape.dtype),
+            validator.check_tensor_dtype_valid("shape", mstype.TensorType(shape.dtype),
                                                [mstype.int32, mstype.int64], self.name)
             shape = shape.asnumpy().tolist()
         else:
@@ -644,10 +671,20 @@ class Shape(Primitive):
 
     Refer to :func:`mindspore.ops.shape` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+
+    Outputs:
+        tuple[int], the output tuple is constructed by multiple integers,
+        :math:`(x_1, x_2, ..., x_R)`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
         >>> shape = ops.Shape()
         >>> output = shape(input_x)
@@ -673,6 +710,9 @@ class TensorShape(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
         >>> shape = ops.TensorShape()
         >>> output = shape(input_x)
@@ -695,33 +735,30 @@ class Unsqueeze(PrimitiveWithCheck):
         self.axis = axis
 
 
-class DynamicShape(Primitive):
-    """
-    Same as operator TensorShape. DynamicShape will be deprecated in the future.
-    Please use TensorShape instead.
-
-    Supported Platforms:
-        Deprecated
-    """
-
-    @deprecated("1.7", "TensorShape", True)
-    @prim_attr_register
-    def __init__(self, dtype=9):
-        """init Shape"""
-        self.init_prim_io_names(inputs=['tensor'], outputs=['output'])
-        self.add_prim_attr('is_dynamic_shape', True)
-
-
 class Squeeze(Primitive):
     """
     Return the Tensor after deleting the dimension of size 1 in the specified `axis`.
 
     Refer to :func:`mindspore.ops.squeeze` for more details.
 
+    Args:
+        axis (Union[int, tuple(int)]): Specifies the dimension indexes of shape to be removed, which will remove
+            all the dimensions of size 1 in the given axis parameter. If specified, it must be int32 or int64.
+            Default: ``()`` .
+
+    Inputs:
+        - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+
+    Outputs:
+        Tensor, the shape of tensor is :math:`(x_1, x_2, ..., x_S)`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
         >>> squeeze = ops.Squeeze(2)
         >>> output = squeeze(input_x)
@@ -750,10 +787,23 @@ class Transpose(Primitive):
 
     Refer to :func:`mindspore.ops.transpose` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        - **input_perm** (tuple[int]) - The permutation to be converted. The elements in `input_perm` are composed of
+          the indexes of each dimension of `input_x`. The length of `input_perm` and the shape of `input_x` must be
+          the same. Only constant value is allowed. Must be in the range [0, rank(input_x)).
+
+    Outputs:
+        Tensor, the type of output tensor is the same as `input_x` and the shape of output tensor is decided by the
+        shape of `input_x` and the value of `input_perm`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]), mindspore.float32)
         >>> input_perm = (0, 2, 1)
         >>> transpose = ops.Transpose()
@@ -847,6 +897,9 @@ class Unique(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, nn
         >>> input_x = Tensor(np.array([1, 2, 5, 2]), mindspore.int32)
         >>> output = ops.Unique()(input_x)
         >>> print(output)
@@ -889,10 +942,33 @@ class UniqueConsecutive(Primitive):
 
     Refer to :func:`mindspore.ops.unique_consecutive` for more details.
 
+    Args:
+        return_idx (bool, optional): Whether to return the index of where the element in the original input
+            maps to the position in the output. Default: ``False`` .
+        return_counts (bool, optional): Whether to return the counts of each unique element. Default: ``False`` .
+        axis (int, optional): The dimension to apply unique. If ``None`` , the unique of the flattened input is
+            returned. If specified, it must be int32 or int64. Default: ``None`` .
+
+    Inputs:
+        - **x** (Tensor) - The input tensor.
+
+    Outputs:
+        A tensor or a tuple of tensors containing tensor objects (`output`, `idx`, `counts`).
+
+        - `output` has the same type as `x` and is used to represent the output list of unique scalar elements.
+        - If `return_idx` is True, there will be an additional returned tensor, `idx`,
+          which has the same shape as `x` and represents
+          the index of where the element in the original input maps to the position in the output.
+        - If `return_counts` is True, there will be an additional returned tensor, `counts`,
+          which represents the number of occurrences for each unique value or tensor.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> x = Tensor(np.array([1, 1, 2, 2, 3, 1, 1, 2]), mstype.int32)
         >>> unique_consecutive = ops.UniqueConsecutive(True, True, None)
         >>> output, idx, counts = unique_consecutive(x)
@@ -920,18 +996,30 @@ class Gather(Primitive):
     r"""
     Returns the slice of the input tensor corresponding to the elements of `input_indices` on the specified `axis`.
 
-    The following figure shows the calculation process of Gather commonly:
+    Refer to :func:`mindspore.ops.gather` for more details.
 
-    .. image:: Gather.png
+    Args:
+        batch_dims (int, optional): Specifies the number of batch dimensions.
+            It must be less than or equal to the rank of `input_indices`. Default: ``0`` .
 
-    where params represents the input `input_params`, and indices represents the index to be sliced `input_indices`.
+    Inputs:
+        - **input_params** (Tensor) - The original Tensor. The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        - **input_indices** (Tensor) - Index tensor to be sliced, the shape of tensor is :math:`(y_1, y_2, ..., y_S)`.
+          Specifies the indices of elements of the original Tensor. The data type can be int32 or int64.
+        - **axis** (Union(int, Tensor[int])) - Specifies the dimension index to gather indices.
+          When axis is Tensor, the size must be 1.
 
-    Refer to :func:`mindspore.ops.gather` for more details.
+    Outputs:
+        Tensor, the shape of tensor is
+        :math:`input\_params.shape[:axis] + input\_indices.shape + input\_params.shape[axis + 1:]`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> # case1: input_indices is a Tensor with shape (5, ).
         >>> input_params = Tensor(np.array([1, 2, 3, 4, 5, 6, 7]), mindspore.float32)
         >>> input_indices = Tensor(np.array([0, 2, 4, 2, 6]), mindspore.int32)
@@ -988,7 +1076,7 @@ class GatherV2(PrimitiveWithCheck):
         self.init_prim_io_names(inputs=['params', 'indices', 'axis'], outputs=['output'])
 
     def __check__(self, params, indices, axis):
-        validator.check_subclass("params", params['dtype'], mstype.tensor, self.name)
+        validator.check_subclass("params", params['dtype'], mstype.tensor_type, self.name)
         validator.check_tensor_dtype_valid("indices", indices['dtype'], mstype.int_type, self.name)
         validator.check_subclass("axis", axis['dtype'], [mstype.number], self.name)
         axis_v = axis['value']
@@ -997,7 +1085,7 @@ class GatherV2(PrimitiveWithCheck):
         validator.check_int_range(axis_v, -rank, rank, validator.INC_LEFT, "axis", self.name)
 
 
-class SparseGatherV2(PrimitiveWithCheck):
+class SparseGatherV2(Primitive):
     """
     Returns a slice of input tensor based on the specified indices and axis.
 
@@ -1006,18 +1094,19 @@ class SparseGatherV2(PrimitiveWithCheck):
         - **input_indices** (Tensor) - The shape of tensor is :math:`(y_1, y_2, ..., y_S)`.
           Specifies the indices of elements of the original Tensor, must be in the range
           `[0, input_params.shape[axis])`.
-        - **axis** (int) - Specifies the dimension index to gather indices.
+        - **axis** (Union(int, Tensor[int])) - Specifies the dimension index to gather indices.
+          When axis is Tensor, the size must be 1.
 
     Outputs:
         Tensor, the shape of tensor is :math:`(z_1, z_2, ..., z_N)`.
 
-    Raises:
-        TypeError: If `axis` is not an int.
-
     Supported Platforms:
         ``Ascend`` ``GPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_params = Tensor(np.array([[1, 2, 7, 42], [3, 4, 54, 22], [2, 2, 55, 3]]), mindspore.float32)
         >>> input_indices = Tensor(np.array([1, 2]), mindspore.int32)
         >>> axis = 1
@@ -1034,15 +1123,6 @@ class SparseGatherV2(PrimitiveWithCheck):
         self.init_prim_io_names(inputs=['params', 'indices', 'axis'], outputs=['output'])
         self.add_prim_attr('bprop_return_sparse', True)
 
-    def __check__(self, params, indices, axis):
-        validator.check_subclass("params", params['dtype'], mstype.tensor, self.name)
-        validator.check_tensor_dtype_valid("indices", indices['dtype'], mstype.int_type, self.name)
-        validator.check_subclass("axis", axis['dtype'], [mstype.number], self.name)
-        axis_v = axis['value']
-        validator.check_value_type('axis', axis_v, [int], self.name)
-        rank = len(params['shape'])
-        validator.check_int_range(axis_v, -rank, rank, validator.INC_LEFT, "axis", self.name)
-
 
 class Padding(Primitive):
     """
@@ -1050,10 +1130,24 @@ class Padding(Primitive):
 
     Refer to :func:`mindspore.ops.padding` for more details.
 
+    Args:
+        pad_dim_size (int, optional): The value of the last dimension of `x` to be
+            extended, which must be positive. Default: ``8`` .
+
+    Inputs:
+        - **x** (Tensor) - Input Tensor of 2D or higher-dimensional.
+          The last dimension of `x` must be 1. The data type is Number.
+
+    Outputs:
+        Tensor, the padded Tensor.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[8], [10]]), mindspore.float32)
         >>> pad_dim_size = 4
         >>> output = ops.Padding(pad_dim_size)(x)
@@ -1082,10 +1176,23 @@ class UniqueWithPad(Primitive):
 
     Refer to :func:`mindspore.ops.unique_with_pad` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The tensor need to be unique. Must be 1-D vector with types: int32, int64.
+        - **pad_num** (int) - Pad num. The data type is an int.
+
+    Outputs:
+        tuple(Tensor), tuple of 2 tensors, `y` and `idx`.
+
+        - y (Tensor) - The unique elements filled with pad_num, the shape and data type same as `x`.
+        - idx (Tensor) - The index of each value of `x` in the unique output `y`, the shape and data type same as `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1, 1, 2, 2, 3, 3, 4, 5]), mindspore.int32)
         >>> pad_num = 8
         >>> output = ops.UniqueWithPad()(x, pad_num)
@@ -1107,20 +1214,24 @@ class Split(Primitive):
     Refer to :func:`mindspore.ops.split` for more details.
 
     Args:
-        axis (int): Index of the split position. Default: 0.
-        output_num (int): The number of output tensors. Must be positive int. Default: 1.
+        axis (int): Index of the split position. Default: ``0`` .
+        output_num (int): The number of output tensors. Must be positive int. Default: ``1`` .
 
     Inputs:
-        - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        - **input_x** (Tensor) - The shape of tensor is :math:`(x_0, x_1, ..., x_{R-1})`, R >= 1.
 
     Outputs:
         tuple[Tensor], the shape of each output tensor is the same, which is
-        :math:`(y_1, y_2, ..., y_S)`. And the data type is the same with `input_x`.
+        :math:`(x_0, x_1, ..., x_{axis}/{output_num}, ..., x_{R-1})`.
+        And the data type is the same as `input_x`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> split = ops.Split(1, 2)
         >>> x = Tensor(np.array([[1, 1, 1, 1], [2, 2, 2, 2]]), mindspore.int32)
         >>> print(x)
@@ -1168,6 +1279,9 @@ class Rank(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
         >>> rank = ops.Rank()
         >>> output = rank(input_tensor)
@@ -1194,10 +1308,21 @@ class Size(Primitive):
 
     Refer to :func:`mindspore.ops.size` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - Input parameters, the shape of tensor is :math:`(x_1, x_2, ..., x_R)`. The data type is
+          `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
+
+    Outputs:
+        int. A scalar representing the elements' size of `input_x`, tensor is the number of elements
+        in a tensor, :math:`size=x_1*x_2*...x_R`. The data type is an int.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
         >>> size = ops.Size()
         >>> output = size(input_x)
@@ -1211,7 +1336,7 @@ class Size(Primitive):
 
 
 class MatrixDiagV3(Primitive):
-    """
+    r"""
     Constructs a diagonal matrix or a batch of diagonal matrices from a given input Tensor.
 
     .. warning::
@@ -1219,10 +1344,58 @@ class MatrixDiagV3(Primitive):
 
     Refer to :func:`mindspore.ops.matrix_diag` for more details.
 
+    Args:
+        align (str, optional): specifies how superdiagonals and subdiagonals should be aligned.
+            Supported values: ``"RIGHT_LEFT"`` , ``"LEFT_RIGHT"`` , ``"LEFT_LEFT"`` , ``"RIGHT_RIGHT"`` .
+            Default: ``"RIGHT_LEFT"`` .
+
+            - When set to ``"RIGHT_LEFT"`` , the alignment of superdiagonals will be towards the right side
+              (padding the row on the left), while subdiagonals will be towards the left side
+              (padding the row on the right)
+            - When set to ``"LEFT_RIGHT"`` , the alignment of superdiagonals will be towards the left side
+              (padding the row on the right), while subdiagonals will be towards the right side
+              (padding the row on the left)
+            - When set to ``"LEFT_LEFT"`` , the alignment of  both superdiagonals and subdiagonals will be towards
+              the left side(padding the row on the right).
+            - When set to ``"RIGHT_RIGHT"`` , the alignment of both superdiagonals and subdiagonals will be towards
+              the right side(padding the row on the left).
+
+    Inputs:
+        - **x** (Tensor) - The diagonal Tensor.
+        - **k** (Union[int, Tensor], optional) - Diagonal offsets.
+          A Tensor of type int32. Positive value means superdiagonal,
+          0 refers to the main diagonal, and negative value means subdiagonals. `k` can be a single integer
+          (for a single diagonal) or a pair of integers specifying the low and high ends of a matrix band.
+          k[0] must not be larger than k[1]. The value must be in the range of given or derivated `num_rows`
+          and `num_cols`, meaning value of k must be in (-num_rows, num_cols). Default: ``0`` .
+        - **num_rows** (Union[int, Tensor], optional) - The number of rows of the output Tensor.
+          A Tensor of type int32 with only one value. If `num_rows` is -1, indicating that the innermost
+          matrix of the output Tensor is a square
+          matrix, and the real number of rows will be derivated by other inputs. That is
+          :math:`num\_rows = x.shape[-1] - min(k[1], 0)`. Otherwise, the value must be equal or greater than
+          :math:`x.shape[-1] - min(k[1], 0)`. Default: -1.
+        - **num_cols** (Union[int, Tensor], optional) - The number of columns of
+          the output Tensor. A Tensor of type int32 with only one value.
+          If `num_cols` is -1, indicating that the innermost matrix of the output
+          Tensor is a square matrix, and the real number of columns will be derivated by other inputs.
+          That is :math:`num\_cols = x.shape[-1] + max(k[0], 0)`. Otherwise, the value must be equal or
+          greater than :math:`x.shape[-1] - min(k[1], 0)`.  Default: -1.
+        - **padding_value** (Union[int, float, Tensor], optional) - The number to fill the area outside the specified
+          diagonal band. A Tensor with only one value. Have the same dtype as x. Default: ``0`` .
+
+    Outputs:
+        A Tensor. Has the same type as `x`.
+        Suppose `x` has r dimensions with shape :math:`(I, J, ..., M, N)` . The output Tensor has rank r + 1 with shape
+        :math:`(I, J, ..., M, num\_rows, num\_cols)` when only one diagonal is given (k is an integer or k[0] == k[1]).
+        Otherwise, it has rank r with shape :math:`(I, J, ..., num\_rows, num\_cols)` .
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[8, 9, 0],
         ...                      [1, 2, 3],
         ...                      [0, 4, 5]]), mindspore.float32)
@@ -1257,10 +1430,46 @@ class MatrixDiagPartV3(Primitive):
 
     Refer to :func:`mindspore.ops.matrix_diag_part` for more details.
 
+    Args:
+        align (str, optional): specifies how superdiagonals and subdiagonals should be aligned.
+            Supported values: ``"RIGHT_LEFT"`` , ``"LEFT_RIGHT"`` , ``"LEFT_LEFT"`` , ``"RIGHT_RIGHT"`` .
+            Default: ``"RIGHT_LEFT"`` .
+
+            - When set to ``"RIGHT_LEFT"`` , the alignment of superdiagonals will be towards the right side
+              (padding the row on the left), while subdiagonals will be towards the left side
+              (padding the row on the right)
+            - When set to ``"LEFT_RIGHT"`` , the alignment of superdiagonals will be towards the left side
+              (padding the row on the right), while subdiagonals will be towards the right side
+              (padding the row on the left)
+            - When set to ``"LEFT_LEFT"`` , the alignment of  both superdiagonals and subdiagonals will be towards
+              the left side(padding the row on the right).
+            - When set to ``"RIGHT_RIGHT"`` , the alignment of both superdiagonals and subdiagonals will be towards
+              the right side(padding the row on the left).
+
+    Inputs:
+        - **x** (Tensor) - Rank r, where r >= 2.
+        - **k** (Tensor) - A Tensor of type int32. Diagonal offset(s). Positive value means superdiagonal, 0 refers to
+          the main diagonal, and negative value means subdiagonals. k can be a single integer (for a single diagonal) or
+          a pair of integers specifying the low and high ends of a matrix band. k[0] must not be larger than k[1]. The
+          value of k has restructions, meaning value of k must be in (-x.shape[-2], x.shape[-1]).
+        - **padding_value** (Tensor) - A Tensor. Have the same dtype as x. The number to fill the area outside the
+          specified diagonal band with. There must be only one value.
+
+    Outputs:
+        A Tensor. Has the same type as `x`.
+        Assume `x` has r dimensions :math:`(I, J, ..., M, N)` . Let `max_diag_len` be the maximum length among all
+        diagonals to be extracted, :math:`max\_diag\_len = min(M + min(k[1], 0), N + min(-k[0], 0))`
+        Let `num_diags` be the number of diagonals to extract, :math:`num\_diags = k[1] - k[0] + 1`.
+        If :math:`num\_diags == 1`, the output tensor is of rank r - 1 with shape :math:`(I, J, ..., L, max\_diag\_len)`
+        Otherwise, the output tensor has rank r with dimensions :math:`(I, J, ..., L, num\_diags, max\_diag\_len)` .
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[1, 2, 3, 4],
         ...                      [5, 6, 7, 8],
         ...                      [9, 8, 7, 6]]), mindspore.float32)
@@ -1310,18 +1519,18 @@ class MatrixSetDiagV3(Primitive):
 
     Args:
         align (str, optional): specifies how superdiagonals and subdiagonals should be aligned.
-            Supported values:"RIGHT_LEFT", "LEFT_RIGHT", "LEFT_LEFT", "RIGHT_RIGHT".
-            Default: "RIGHT_LEFT".
+            Supported values: ``"RIGHT_LEFT"`` , ``"LEFT_RIGHT"``, ``"LEFT_LEFT"`` , ``"RIGHT_RIGHT"`` .
+            Default: ``"RIGHT_LEFT"`` .
 
-            - When set to "RIGHT_LEFT", the alignment of superdiagonals will be towards the right side
+            - When set to ``"RIGHT_LEFT"`` , the alignment of superdiagonals will be towards the right side
               (padding the row on the left), while subdiagonals will be towards the left side
               (padding the row on the right)
-            - When set to "LEFT_RIGHT", the alignment of superdiagonals will be towards the left side
+            - When set to ``"LEFT_RIGHT"`` , the alignment of superdiagonals will be towards the left side
               (padding the row on the right), while subdiagonals will be towards the right side
               (padding the row on the left)
-            - When set to "LEFT_LEFT", the alignment of  both superdiagonals and subdiagonals will be towards
+            - When set to ``"LEFT_LEFT"`` , the alignment of  both superdiagonals and subdiagonals will be towards
               the left side(padding the row on the right).
-            - When set to "RIGHT_RIGHT", the alignment of both superdiagonals and subdiagonals will be towards
+            - When set to ``"RIGHT_RIGHT"`` , the alignment of both superdiagonals and subdiagonals will be towards
               the right side(padding the row on the left).
 
     Inputs:
@@ -1355,15 +1564,19 @@ class MatrixSetDiagV3(Primitive):
         ValueError: If `k[1]` is not greater equal to `k[0]` in case the size of `k` is 2.
         ValueError: If the `diagonal` rank size don't match with input `x` rank size.
         ValueError: If the `diagonal` shape value don't match with input `x` shape value.
-        ValueError: If the diagonal :math:`shape[-2]` is not equal to num_diags calculated by :math:`k[1] - k[0] + 1` .
+        ValueError: If the diagonal :math:`shape[-2]` is not equal to num_diags calculated by
+            :math:`num\_diags = k[1] - k[0] + 1` .
         ValueError: If the value of `k` is not in :math:`(-x.shape[-2], x.shape[-1])`.
         ValueError: If the diagonal :math:`shape[-1]` is not equal to the max_diag_len calculated by
-            :math:`min(x.shape[-2] + min(k[1], 0), x.shape[-1] + min(-k[0], 0))` .
+            :math:`max\_diag\_len = min(x.shape[-2] + min(k[1], 0), x.shape[-1] + min(-k[0], 0))` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[7, 7, 7, 7],
         ...                      [7, 7, 7, 7],
         ...                      [7, 7, 7, 7]]), mindspore.float32)
@@ -1403,10 +1616,25 @@ class MatrixBandPart(Primitive):
 
     Refer to :func:`mindspore.ops.matrix_band_part` for more details.
 
-    Supported Platforms:
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Inputs:
+        - **x** (Tensor) - Input tensor. :math:`(*, m, n)` where :math:`*` means, any number of additional dimensions.
+        - **lower** (Union[int, Tensor]) - Number of subdiagonals to keep. The data type must be int32 or int64.
+          If negative, keep entire lower triangle.
+        - **upper** (Union[int, Tensor]) - Number of superdiagonals to keep. The data type must be int32 or int64.
+          If negative, keep entire upper triangle.
 
+    Outputs:
+        Tensor, has the same type and shape as `x`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> matrix_band_part = ops.MatrixBandPart()
         >>> x = np.ones([2, 4, 4]).astype(np.float32)
         >>> output = matrix_band_part(Tensor(x), 2, 1)
@@ -1455,7 +1683,7 @@ class Fill(PrimitiveWithCheck):
         if isinstance(x, Tensor):
             x = x.asnumpy()
         ret = np.full(dims, x, x_nptype)
-        return Tensor(ret)
+        return Tensor(ret, dtype=dtype)
 
     def infer_value(self, dtype, dims, x):
         x_nptype = mstype.dtype_to_nptype(dtype)
@@ -1465,7 +1693,7 @@ class Fill(PrimitiveWithCheck):
             if isinstance(x, Tensor):
                 x = x.asnumpy()
             ret = np.full(dims, x, x_nptype)
-            return Tensor(ret)
+            return Tensor(ret, dtype=dtype)
         return None
 
 
@@ -1515,6 +1743,8 @@ class FillV2(PrimitiveWithCheck):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> fillV2 = ops.FillV2()
         >>> output = fillV2(Tensor([2, 3], mindspore.int32), Tensor(1, mindspore.float32))
         >>> print(output)
@@ -1532,15 +1762,19 @@ class FillV2(PrimitiveWithCheck):
         """Initialize FillV2"""
         self.init_prim_io_names(inputs=['shape', 'value'], outputs=['y'])
 
+    def check_elim(self, dims, x):
+        if x is None or (not isinstance(x, (Tensor, Tensor_))) or (x.shape != ()) or\
+            dims is None or (isinstance(dims, (tuple, list)) and dims) or\
+            isinstance(dims, (Tensor, Tensor_)):
+            return (False, None)
+        return (True, x)
+
     def infer_value(self, dims, x):
-        if isinstance(dims, (Tensor, Tensor_)):
-            dims = dims.asnumpy()
-        if isinstance(x, (Tensor, Tensor_)):
-            x = x.asnumpy()
-        if dims is not None and None not in dims and x is not None:
-            ret = np.full(dims, x)
-            return Tensor(ret)
-        return None
+        if x is None or dims is None or\
+            (isinstance(dims, (tuple, list)) and dims) or\
+            isinstance(dims, (Tensor, Tensor_)):
+            return None
+        return x
 
 
 class Ones(Primitive):
@@ -1560,6 +1794,8 @@ class Ones(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
         >>> ones = ops.Ones()
         >>> output = ones((2, 2), mindspore.float32)
         >>> print(output)
@@ -1601,6 +1837,8 @@ class Zeros(Primitive):
         Deprecated
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
         >>> zeros = ops.Zeros()
         >>> output = zeros((2, 2), mindspore.float32)
         >>> print(output)
@@ -1620,10 +1858,18 @@ class OnesLike(Primitive):
 
     Refer to :func:`mindspore.ops.ones_like` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - Tensor of any dimension.
+
+    Outputs:
+        Tensor, has the same shape and type as `input_x` but filled with ones.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> oneslike = ops.OnesLike()
         >>> input_x = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))
         >>> output = oneslike(input_x)
@@ -1643,7 +1889,7 @@ class ZerosLike(Primitive):
     Returns a Tensor with a value of 0 and its shape and data type is the same as the input.
 
     Inputs:
-        - **input_x** (Tensor) - Input Tensor of any dimension. The data type is Number.
+        - **input_x** (Tensor) - Input Tensor of any dimension.
 
     Outputs:
         Tensor, has the same shape and data type as `input_x` but filled with zeros.
@@ -1655,6 +1901,8 @@ class ZerosLike(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> zeroslike = ops.ZerosLike()
         >>> input_x = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
         >>> output = zeroslike(input_x)
@@ -1675,10 +1923,18 @@ class TupleToArray(PrimitiveWithInfer):
 
     Refer to :func:`mindspore.ops.tuple_to_array` for more details.
 
+    Inputs:
+        - **input_x** (tuple) - A tuple of numbers. These numbers have the same type.
+          The shape is :math:`(N,*)` where :math:`*` means any number of additional dimensions.
+
+    Outputs:
+        Tensor, if the input tuple contains `N` numbers, then the shape of the output tensor is :math:`(N,)`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import ops
         >>> input_x = (1,2,3)
         >>> print(type(input_x))
         <class 'tuple'>
@@ -1707,7 +1963,8 @@ class TupleToArray(PrimitiveWithInfer):
             ret = np.array(x, np.float32)
         return Tensor(ret)
 
-    def __call__(self, x):
+    def __call__(self, *args):
+        x, = args
         args = list()
         if isinstance(x, range):
             args.append(tuple(x))
@@ -1716,34 +1973,26 @@ class TupleToArray(PrimitiveWithInfer):
         return _run_op(self, self.name, args)
 
 
-class ScalarToArray(PrimitiveWithInfer):
-    """
-    The `ScalarToArray` primitive  is deprecated. Please use the :class:`mindspore.ops.ScalarToTensor` instead.
-    """
-    @deprecated("2.0", "ops.scalar_to_tensor", False)
-    @prim_attr_register
-    def __init__(self):
-        pass
-
-    def infer_value(self, x):
-        validator.check_value_type("x", x, [int, float], self.name)
-        if isinstance(x, int):
-            ret = np.array(x, np.int32)
-        else:
-            ret = np.array(x, np.float32)
-        return Tensor(ret)
-
-
 class ScalarToTensor(PrimitiveWithInfer):
     """
     Converts a scalar to a `Tensor`, and converts the data type to the specified type.
 
     Refer to :func:`mindspore.ops.scalar_to_tensor` for more details.
 
+    Inputs:
+        - **input_x** (Union[int, float]) - The input is a scalar. Only constant value is allowed.
+        - **dtype** (mindspore.dtype) - The target data type. Default: ``mindspore.float32`` . Only
+          constant value is allowed.
+
+    Outputs:
+        Tensor. 0-D Tensor and the content is the input.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
         >>> op = ops.ScalarToTensor()
         >>> data = 1
         >>> output = op(data, mindspore.float32)
@@ -1759,7 +2008,7 @@ class ScalarToTensor(PrimitiveWithInfer):
         validator.check_value_type("x", x, [bool, int, float], self.name)
         validator.check_subclass("dtype", dtype, mstype.number, self.name)
         data_type = mstype.dtype_to_nptype(dtype)
-        return Tensor(np.array(x, data_type))
+        return Tensor(np.array(x, data_type), dtype=dtype)
 
 
 class InvertPermutation(PrimitiveWithInfer):
@@ -1794,6 +2043,7 @@ class InvertPermutation(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import ops
         >>> invert = ops.InvertPermutation()
         >>> input_data = (3, 4, 0, 2, 1)
         >>> output = invert(input_data)
@@ -1804,12 +2054,11 @@ class InvertPermutation(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self):
         """Initialize InvertPermutation"""
-        self.set_const_prim(True)
 
     def __infer__(self, x):
         x_shp = x['shape']
         x_value = x['value']
-        if mstype._issubclass_(x['dtype'], mstype.tensor):  # pylint: disable=W0212
+        if mstype._issubclass_(x['dtype'], mstype.tensor_type):  # pylint: disable=W0212
             raise ValueError(f"For \'{self.name}\', the value of 'input_x' must be non-Tensor, but got {x['dtype']}")
         if x_value is None:
             raise ValueError(f"For '{self.name}', the value of 'input_x' can not be None, but got {x_value}.")
@@ -1843,22 +2092,18 @@ class InvertPermutation(PrimitiveWithInfer):
 
 class Argmax(Primitive):
     """
-    Returns the indices of the maximum value of a tensor across the axis.
+    Returns the indices of the maximum value along a specified `axis` of a Tensor.
 
     Refer to :func:`mindspore.ops.argmax` for more details.
 
     Args:
-        axis (int): Axis where the Argmax operation applies to. Default: -1.
-        output_type (:class:`mindspore.dtype`): An optional data type of `mindspore.dtype.int32`.
-            Default: `mindspore.dtype.int32`.
+        axis (int): Axis where the Argmax operation applies to. Default: ``-1`` .
+        output_type (:class:`mindspore.dtype`): Output data type.
+            Supported types: ``mstype.int32`` , ``mstype.int64`` . Default: ``mstype.int32`` .
 
     Inputs:
-        - **input_x** (Tensor) - Input tensor. :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
-          Support data type list as follows:
-
-          - Ascend: Float16, Float32.
-          - GPU: Float16, Float32.
-          - CPU: Float16, Float32, Float64.
+        - **input_x** (Tensor) - The input tensor. :math:`(N, *)` where :math:`*` means, any number of additional
+          dimensions.
 
     Outputs:
         Tensor, indices of the max value of input tensor across the axis.
@@ -1867,6 +2112,9 @@ class Argmax(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[1, 20, 5], [67, 8, 9], [130, 24, 15]]).astype(np.float32))
         >>> output = ops.Argmax(output_type=mindspore.int32)(input_x)
         >>> print(output)
@@ -1885,22 +2133,20 @@ class Argmax(Primitive):
 
 class Argmin(Primitive):
     """
-    Returns the indices of the minimum value of a tensor across the axis.
+    Returns the indices of the minimum value along a specified `axis` of a Tensor.
 
     If the shape of input tensor is :math:`(x_1, ..., x_N)`, the shape of the output tensor is
     :math:`(x_1, ..., x_{axis-1}, x_{axis+1}, ..., x_N)`.
 
     Args:
-        axis (int): Axis where the Argmin operation applies to. Default: -1.
-        output_type (:class:`mindspore.dtype`): An optional data type of `mindspore.dtype.int32` and
-            `mindspore.dtype.int64`. Default: `mindspore.dtype.int32`.
+        axis (int): Axis where the Argmin operation applies to. Default: ``-1`` .
+        output_type (:class:`mindspore.dtype`): Output data type.
+            Supported types: ``mstype.int32`` , ``mstype.int64`` . Default: ``mstype.int32`` .
 
     Inputs:
         - **input_x** (Tensor) - Input tensor.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
 
-          - Ascend: Float16, Float32, Float64, Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64.
-
     Outputs:
         Tensor, whose dtype is determined by `output_type`.
 
@@ -1912,6 +2158,9 @@ class Argmin(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([2.0, 3.1, 1.2]), mindspore.float32)
         >>> index = ops.Argmin()(input_x)
         >>> print(index)
@@ -1942,7 +2191,7 @@ class ArgminV2(Primitive):
     Inputs:
         - **x** (Tensor) - Input tensor.
           The shape is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
-        - **axis** (int) - Axis where the Argmin operator applies to. Default: -1.
+        - **axis** (int) - Axis where the Argmin operator applies to. Default: ``-1`` .
 
     Outputs:
         Tensor, indices of the min value of input tensor across the axis.
@@ -1999,12 +2248,12 @@ class ArgMaxWithValue(Primitive):
         - If there are multiple maximum values, the index of the first maximum value is used.
         - The value range of "axis" is [-dims, dims - 1]. "dims" is the dimension length of "x".
 
-    Also see: func: `mindspore.ops.max`.
+    Also see :func:`mindspore.ops.max`.
 
     Args:
-        axis (int): The dimension to reduce. Default: 0.
-        keep_dims (bool): Whether to reduce dimension, if true, the output will keep same dimension with the input,
-                          the output will reduce dimension if false. Default: False.
+        axis (int): The dimension to reduce. Default: ``0`` .
+        keep_dims (bool): Whether to reduce dimension, if ``True`` , the output will keep same dimension with the
+                          input, the output will reduce dimension if ``false`` . Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - The input tensor, can be any dimension. Set the shape of input tensor as
@@ -2015,7 +2264,7 @@ class ArgMaxWithValue(Primitive):
         tensor.
 
         - **index** (Tensor) - The index for the maximum value of the input tensor, with dtype int32. If `keep_dims`
-          is true, the shape of output tensors is :math:`(x_1, x_2, ..., x_{axis-1}, 1, x_{axis+1}, ..., x_N)`.
+          is ``True`` , the shape of output tensors is :math:`(x_1, x_2, ..., x_{axis-1}, 1, x_{axis+1}, ..., x_N)`.
           Otherwise, the shape is :math:`(x_1, x_2, ..., x_{axis-1}, x_{axis+1}, ..., x_N)` .
         - **values** (Tensor) - The maximum value of input tensor, with the same shape as index, and same dtype as x.
 
@@ -2028,6 +2277,9 @@ class ArgMaxWithValue(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
         >>> index, output = ops.ArgMaxWithValue()(input_x)
         >>> print(index, output)
@@ -2060,12 +2312,12 @@ class ArgMinWithValue(Primitive):
         - If there are multiple minimum values, the index of the first minimum value is used.
         - The value range of "axis" is [-dims, dims - 1]. "dims" is the dimension length of "x".
 
-    Also see: func: `mindspore.ops.min`.
+    Also see :func:`mindspore.ops.min`.
 
     Args:
-        axis (int): The dimension to reduce. Default: 0.
-        keep_dims (bool): Whether to reduce dimension, if true the output will keep the same dimension as the input,
-                          the output will reduce dimension if false. Default: False.
+        axis (int): The dimension to reduce. Default: ``0`` .
+        keep_dims (bool): Whether to reduce dimension, if ``True`` the output will keep the same dimension as the
+                          input, the output will reduce dimension if ``false`` . Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - The input tensor, can be any dimension. Set the shape of input tensor as
@@ -2076,7 +2328,7 @@ class ArgMinWithValue(Primitive):
         tensor.
 
         - **index** (Tensor) - The index for the minimum value of the input tensor, with dtype int32. If `keep_dims`
-          is true, the shape of output tensors is :math:`(x_1, x_2, ..., x_{axis-1}, 1, x_{axis+1}, ..., x_N)`.
+          is ``True`` , the shape of output tensors is :math:`(x_1, x_2, ..., x_{axis-1}, 1, x_{axis+1}, ..., x_N)`.
           Otherwise, the shape is :math:`(x_1, x_2, ..., x_{axis-1}, x_{axis+1}, ..., x_N)` .
         - **values** (Tensor) - The minimum value of input tensor, with the same
           shape as `index`, and same dtype as `x`.
@@ -2090,6 +2342,9 @@ class ArgMinWithValue(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
         >>> index, output = ops.ArgMinWithValue()(x)
         >>> print(index, output)
@@ -2116,10 +2371,32 @@ class Tile(PrimitiveWithInfer):
 
     Refer to :func:`mindspore.ops.tile` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - 1-D or higher dimensional Tensor. Set the shape of input tensor as
+          :math:`(x_1, x_2, ..., x_S)` .
+        - **multiples** (tuple[int]) - The parameter that specifies the number of replications,
+          the parameter type is tuple, and the data type is int, i.e., :math:`(y_1, y_2, ..., y_S)`.
+          The length of `multiples` cannot be smaller than the length of the shape of `input_x`.
+          Only constant value is allowed.
+
+    Outputs:
+        Tensor, has the same data type as the `input_x`. Suppose the length of `multiples` is `d`,
+        the dimension of `input_x` is `input_x.dim`, and the shape of `input_x` is :math:`(x_1, x_2, ..., x_S)`.
+
+        - If `input_x.dim = d`, then the shape of their corresponding positions can be multiplied, and
+          the shape of Outputs is :math:`(x_1*y_1, x_2*y_2, ..., x_S*y_S)`.
+        - If `input_x.dim < d`, fill in multiple 1 in the length of the shape of `input_x` until their
+          lengths are consistent. Such as set the shape of `input_x` as :math:`(1, ..., x_1, x_2, ..., x_S)`,
+          then the shape of their corresponding positions can be multiplied, and the shape of Outputs is
+          :math:`(1*y_1, ..., x_R*y_R, x_S*y_S)`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> tile = ops.Tile()
         >>> input_x = Tensor(np.array([[1, 2], [3, 4]]), mindspore.float32)
         >>> multiples = (2, 3)
@@ -2151,7 +2428,10 @@ class Tile(PrimitiveWithInfer):
         """Initialize Tile"""
         self.init_prim_io_names(inputs=['x', 'multiples'], outputs=['output'])
 
-    def check_elim(self, base_tensor, multiplier):
+    def check_elim(self, *args):
+        base_tensor, multiplier = args
+        if PackFunc.is_tracing() and not PackFunc.current.is_pynative_mode:
+            return (False, None)
         if not isinstance(base_tensor, Tensor):
             raise TypeError(f"For '{self.name}', the type of 'input_x' must be Tensor, "
                             f"but got {type(base_tensor).__name__}.")
@@ -2206,6 +2486,8 @@ class Tile(PrimitiveWithInfer):
                     raise ValueError(f'For \'{self.name}\', the dim of multiples must be 1.')
                 rank = max(len(x['shape']), shape[0])
                 out_shape = [-1] * rank
+                if -2 in x['shape']:
+                    out_shape = [-2]
                 return {
                     'shape': out_shape,
                     'dtype': x['dtype'],
@@ -2224,7 +2506,7 @@ class Tile(PrimitiveWithInfer):
             validator.check_positive_int(
                 multiple, "multiples[%d]" % i, self.name)
         validator.check_value_type(
-            "x[\'dtype\']", x["dtype"], mstype.tensor_type, self.name)
+            "x[\'dtype\']", x["dtype"], mstype.TensorType, self.name)
         out_shp, value = self._get_shape_and_range(x, multiples)
         shp = out_shp.get('shape', None)
         out = {'shape': shp,
@@ -2239,6 +2521,16 @@ class UnsortedSegmentSum(Primitive):
 
     Refer to :func:`mindspore.ops.unsorted_segment_sum` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - Input Tensor contains the data to be summed.
+          The shape is :math:`(x_1, x_2, ..., x_R)`.
+        - **segment_ids** (Tensor) - The label indicates the segment to which each element belongs.
+          Set the shape as :math:`(x_1, x_2, ..., x_N)`, where 0 < N <= R.
+        - **num_segments** (int) - Set :math:`z` as num_segments, it can be an int or 0-D Tensor.
+
+    Outputs:
+        Tensor, the shape is :math:`(z, x_{N+1}, ..., x_R)`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -2272,6 +2564,16 @@ class UnsortedSegmentMin(PrimitiveWithCheck):
 
     Refer to :func:`mindspore.ops.unsorted_segment_min` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The shape is :math:`(x_1, x_2, ..., x_R)`.
+          The data type must be float16, float32 or int32.
+        - **segment_ids** (Tensor) - The label indicates the segment to which each element belongs.
+          Set the shape as :math:`(x_1, x_2, ..., x_N)`, where 0 < N <= R.
+        - **num_segments** (int) - The value specifies the number of distinct `segment_ids`.
+
+    Outputs:
+        Tensor, set the number of `num_segments` as `N`, the shape is :math:`(N, x_2, ..., x_R)`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -2305,7 +2607,7 @@ class UnsortedSegmentMin(PrimitiveWithCheck):
         # support vmap : segment_ids_shape support batch rank
         if not hasattr(self, 'batch_rank'):
             if not is_dim_unknown(x_shape) and not is_dim_unknown(segment_ids_shape):
-                validator.check_equal_int(len(segment_ids_shape), 1, "rank of segment_ids_shape", self.name)
+                validator.check_int(len(segment_ids_shape), 1, validator.GE, "rank of segment_ids_shape", self.name)
 
         num_segments_type = num_segments['dtype']
         validator.check_subclass("num_segments", num_segments_type, [mstype.number], self.name)
@@ -2324,6 +2626,16 @@ class UnsortedSegmentMax(PrimitiveWithCheck):
 
     Refer to :func:`mindspore.ops.unsorted_segment_max` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The shape is :math:`(x_1, x_2, ..., x_R)`.
+          The data type must be float16, float32 or int32.
+        - **segment_ids** (Tensor) - The label indicates the segment to which each element belongs.
+          Set the shape as :math:`(x_1, x_2, ..., x_N)`, where 0 < N <= R.
+        - **num_segments** (int) - The value specifies the number of distinct `segment_ids`.
+
+    Outputs:
+        Tensor, set the number of `num_segments` as `N`, the shape is :math:`(N, x_2, ..., x_R)`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -2415,7 +2727,7 @@ class UnsortedSegmentMax(PrimitiveWithCheck):
         # support vmap : segment_ids_shape support batch rank
         if not hasattr(self, 'batch_rank'):
             if not is_dim_unknown(x_shape) and not is_dim_unknown(segment_ids_shape):
-                validator.check_equal_int(len(segment_ids_shape), 1, "rank of segment_ids_shape", self.name)
+                validator.check_int(len(segment_ids_shape), 1, validator.GE, "rank of segment_ids_shape", self.name)
 
         num_segments_type = num_segments['dtype']
         validator.check_subclass("num_segments", num_segments_type, [mstype.number], self.name)
@@ -2424,8 +2736,9 @@ class UnsortedSegmentMax(PrimitiveWithCheck):
             validator.check(f'first shape of input_x', x_shape[0],
                             'length of segments_id', segment_ids_shape[0], validator.EQ, self.name)
         num_segments_v = num_segments['value']
-        validator.check_value_type('num_segments', num_segments_v, [int], self.name)
-        validator.check_positive_int(num_segments_v, "num_segments", self.name)
+        if num_segments_v is not None:
+            validator.check_value_type('num_segments', num_segments_v, [int], self.name)
+            validator.check_positive_int(num_segments_v, "num_segments", self.name)
 
 
 class UnsortedSegmentProd(Primitive):
@@ -2434,6 +2747,17 @@ class UnsortedSegmentProd(Primitive):
 
     Refer to :func:`mindspore.ops.unsorted_segment_prod` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The shape is :math:`(x_1, x_2, ..., x_R)`.
+          With float16, float32 or int32 data type.
+        - **segment_ids** (Tensor) - A `1-D` tensor whose shape is :math:`(x_1)`, the value must be non-negative tensor.
+          Data type must be int32.
+        - **num_segments** (int) - The value specifies the number of distinct `segment_ids`,
+          must be greater than 0.
+
+    Outputs:
+        Tensor, set the number of `num_segments` as `N`, the shape is :math:`(N, x_2, ..., x_R)`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -2463,10 +2787,26 @@ class Concat(PrimitiveWithCheck):
 
     Refer to :func:`mindspore.ops.concat` for more details.
 
+    Args:
+        axis (int, optional): The specified axis. Default: ``0`` .
+
+    Inputs:
+        - **input_x** (Union[tuple, list]) - A tuple or a list of input tensors.
+          Suppose there are two tensors in this tuple or list, namely x1 and x2.
+          To perform `Concat` in the axis 0 direction, except for the 0th axis, all other axes should be equal,
+          that is, :math:`x1.shape[1] == x2.shape[1], x1.shape[2] == x2.shape[2], ..., x1.shape[R] == x2.shape[R]`,
+          where the :math:`R` indicates the last axis.
+
+    Outputs:
+        - Tensor, the shape is :math:`(x_1, x_2, ..., \sum_{i=1}^Nx_{mi}, ..., x_R)`.
+          The data type is the same with `input_x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x1 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
         >>> input_x2 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
         >>> op = ops.Concat()
@@ -2586,6 +2926,8 @@ class ParallelConcat(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> data1 = Tensor(np.array([[0, 1]]).astype(np.int32))
         >>> data2 = Tensor(np.array([[2, 1]]).astype(np.int32))
         >>> op = ops.ParallelConcat()
@@ -2604,11 +2946,12 @@ def _get_stack_shape(value, x_shape, x_type, axis, prim_name):
     """for stack output shape"""
     validator.check_value_type("shape", x_shape, [tuple, list], prim_name)
     validator.check_int(len(x_shape), 1, validator.GE, "len of input_x", prim_name)
-    validator.check_subclass("input_x[0]", x_type[0], mstype.tensor, prim_name)
+    validator.check_subclass("input_x[0]", x_type[0], mstype.tensor_type, prim_name)
 
     out_n = len(x_shape)
     for i in range(1, out_n):
-        validator.check('x_type[%d]' % i, x_type[i], 'base', x_type[0], validator.EQ, prim_name, TypeError)
+        if x_type[i] != x_type[i-1]:
+            raise TypeError(f"For {prim_name}, all types should be same, but got {x_type}")
 
     new_x_shape = []
     for i, shp in enumerate(x_shape):
@@ -2630,8 +2973,8 @@ def _get_stack_shape(value, x_shape, x_type, axis, prim_name):
         for j in range(0, rank_base):
             if new_x_shape[i]["shape"][j] != new_x_shape[0]["shape"][j] and \
                     new_x_shape[i]["shape"][j] != -1 and new_x_shape[0]["shape"][j] != -1:
-                raise ValueError("For \'{}\' element {} shape in input can not pack with first element".format(
-                    prim_name, new_x_shape[i]['id']))
+                raise ValueError(f"For {prim_name} element {new_x_shape[i]['id']} shape"
+                                 f"in input can not pack with first element")
 
     validator.check_int_range(axis, -rank_base - 1, rank_base, validator.INC_BOTH, 'axis', prim_name)
     if axis < 0:
@@ -2647,40 +2990,28 @@ def _get_stack_shape(value, x_shape, x_type, axis, prim_name):
     return out_shape
 
 
-class Pack(PrimitiveWithInfer):
-    """
-    Same as operator Stack. Pack will be deprecated in the future.
-    Please use Stack instead.
-    """
-
-    @deprecated("1.1", "Stack", True)
-    @prim_attr_register
-    def __init__(self, axis=0):
-        """Initialize Pack"""
-        validator.check_value_type("axis", axis, [int], self.name)
-        self.axis = axis
-
-    def __infer__(self, value):
-        x_shape = value['shape']
-        x_type = value['dtype']
-        self.add_prim_attr('num', len(x_shape))
-        all_shape = _get_stack_shape(value, x_shape, x_type, self.axis, self.name)
-        out = {'shape': all_shape,
-               'dtype': x_type[0],
-               'value': None}
-        return out
-
-
 class Stack(PrimitiveWithInfer):
     r"""
     Stacks a list of tensors in specified axis.
 
     Refer to :func:`mindspore.ops.stack` for more details.
 
+    Args:
+        axis (int, optional): Dimension to stack. The range is [-(R+1), R+1). Default: ``0`` .
+
+    Inputs:
+        - **input_x** (Union[tuple, list]) - A Tuple or list of Tensor objects with the same shape and type.
+
+    Outputs:
+        Tensor. A stacked Tensor with the same type as `input_x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> import numpy as np
         >>> data1 = Tensor(np.array([0, 1]).astype(np.float32))
         >>> data2 = Tensor(np.array([2, 3]).astype(np.float32))
         >>> stack = ops.Stack()
@@ -2723,75 +3054,30 @@ class Stack(PrimitiveWithInfer):
                 return unpack(x[0])
             return x
 
-        if 'shape_value' in value and value['shape_value'] is not None:
-            input_shape_value = []
-            for item in value['shape_value']:
-                item = unpack(item)
-                item = np.array(item)
-                input_shape_value.append(item)
-            infered_shape_value = np.stack(input_shape_value, axis=self.axis)
-            infered_shape_value = tuple(infered_shape_value.tolist())
-            out['shape_value'] = infered_shape_value
-        return out
-
-
-class Unpack(PrimitiveWithInfer):
-    """
-    Same as operator Unstack. Unpack will be deprecated in the future.
-    Please use Unstack instead.
-    """
-
-    @deprecated("1.1", "Unstack", True)
-    @prim_attr_register
-    def __init__(self, axis=0):
-        """Initialize Unpack"""
-        validator.check_value_type("axis", axis, [int], self.name)
-        self.axis = axis
-
-    def __infer__(self, x):
-        validator.check_subclass("x", x['dtype'], mstype.tensor, self.name)
-        x_shape = list(x['shape'])
-        dim = len(x_shape)
-        validator.check_int_range(self.axis, -dim, dim, validator.INC_LEFT, 'axis value', self.name)
-        if self.axis < 0:
-            self.axis = self.axis + dim
-        output_num = x_shape[self.axis]
-        validator.check_value_type("num", output_num, [int], self.name)
-        validator.check_positive_int(output_num, "output_num", self.name)
-        self.add_prim_attr('num', output_num)
-        output_valid_check = x_shape[self.axis] - output_num
-        validator.check_int(output_valid_check, 0, validator.EQ,
-                            "The dimension which to unstack divides output_num", self.name)
-        out_shapes = []
-        out_dtypes = []
-        out_shape = x_shape[:self.axis] + x_shape[self.axis + 1:]
-        for _ in range(output_num):
-            out_shapes.append(tuple(out_shape))
-            out_dtypes.append(x['dtype'])
-        out_shapes = tuple(out_shapes)
-        out_dtypes = tuple(out_dtypes)
-        out = {'shape': out_shapes,
-               'dtype': out_dtypes,
-               'value': None}
+        if 'shape_value' in value and value['shape_value'] is not None:
+            input_shape_value = []
+            for item in value['shape_value']:
+                item = unpack(item)
+                item = np.array(item)
+                input_shape_value.append(item)
+            infered_shape_value = np.stack(input_shape_value, axis=self.axis)
+            infered_shape_value = tuple(infered_shape_value.tolist())
+            out['shape_value'] = infered_shape_value
         return out
 
 
 class Unstack(Primitive):
     r"""
-    Unstacks tensor in specified axis.
-
-    Unstacks a tensor of rank `R` along axis dimension, output tensors will have rank `(R-1)`.
+    Unstacks tensor in specified axis, this is the opposite of ops.Stack.
+    Assuming input is a tensor of rank `R`, output tensors will have rank `(R-1)`.
 
-    Given a tensor of shape :math:`(x_1, x_2, ..., x_R)`. If :math:`0 \le axis`,
-    the shape of tensor in output is :math:`(x_1, x_2, ..., x_{axis}, x_{axis+2}, ..., x_R)`.
-
-    This is the opposite of pack.
+    Refer to :func:`mindspore.ops.unstack` for more details.
 
     Args:
-        axis (int): Dimension along which to unpack. Default: 0.
+        axis (int): Dimension along which to unpack. Default: ``0`` .
             Negative values wrap around. The range is [-R, R).
         num (Union[None, int]): The number of output tensors.
-            Automatically inferred by input_x and axis if None. Default: None.
+            Automatically inferred by input_x and axis if ``None`` . Default: ``None`` .
 
     Inputs:
         - **input_x** (Tensor) - The shape is :math:`(x_1, x_2, ..., x_R)`.
@@ -2799,14 +3085,15 @@ class Unstack(Primitive):
 
     Outputs:
         A tuple of tensors, the shape of each objects is the same.
-
-    Raises:
-        ValueError: If axis is out of the range [-len(input_x.shape), len(input_x.shape)).
+        Given a tensor of shape :math:`(x_1, x_2, ..., x_R)`. If :math:`0 \le axis`,
+        the shape of tensor in output is :math:`(x_1, x_2, ..., x_{axis}, x_{axis+2}, ..., x_R)`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> unstack = ops.Unstack()
         >>> input_x = Tensor(np.array([[1, 1, 1, 1], [2, 2, 2, 2]]))
         >>> output = unstack(input_x)
@@ -2829,6 +3116,15 @@ class Slice(Primitive):
 
     Refer to :func:`mindspore.ops.slice` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The target tensor.
+          The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
+        - **begin** (Union[tuple, list]) - The beginning of the slice. Only constant value(>=0) is allowed.
+        - **size** (Union[tuple, list]) - The size of the slice. Only constant value is allowed.
+
+    Outputs:
+        Tensor, the shape is: input `size`, the data type is the same as `input_x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -2930,7 +3226,7 @@ class ReverseV2(Primitive):
         axis (Union[tuple(int), list(int)]): The indices of the dimensions to reverse.
 
     Inputs:
-        - **input_x** (Tensor) - The target tensor. The data type is Number except float64.
+        - **input_x** (Tensor) - The target tensor.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
 
     Outputs:
@@ -2945,6 +3241,9 @@ class ReverseV2(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[1, 2, 3, 4], [5, 6, 7, 8]]), mindspore.int32)
         >>> op = ops.ReverseV2(axis=[1])
         >>> output = op(input_x)
@@ -2965,6 +3264,9 @@ class ReverseV2(Primitive):
         for i, each in enumerate(axis):
             validator.check_value_type(f'axis[{i}]', each, [int], self.name)
         self.axis = axis
+        if isinstance(axis, list):
+            self.axis = tuple(axis)
+            self.add_prim_attr('axis', self.axis)
         self.init_prim_io_names(inputs=['x'], outputs=['output'])
 
 
@@ -2973,10 +3275,8 @@ class Rint(Primitive):
     Returns an integer that is closest to `input_x` element-wise.
 
     Inputs:
-        - **input_x** (Tensor) - The target tensor, which must be one of the following types:
-          float16, float32, float64. The shape is :math:`(N,*)` where :math:`*` means
-          any number of additional dimensions.
-
+        - **input_x** (Tensor) - Input tensor of any dimension, which must be one of the following types:
+          float16, float32, float64.
     Outputs:
         Tensor, has the same shape and type as `input_x`.
 
@@ -2987,6 +3287,9 @@ class Rint(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([-1.6, -0.1, 1.5, 2.0]), mindspore.float32)
         >>> op = ops.Rint()
         >>> output = op(input_x)
@@ -3037,6 +3340,8 @@ class Select(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> select = ops.Select()
         >>> input_cond = Tensor([True, False])
         >>> input_x = Tensor([2,3], mindspore.float32)
@@ -3059,11 +3364,11 @@ class StridedSliceV2(Primitive):
     Refer to class StridedSlice for more details.
 
     Args:
-        begin_mask (int): Starting index of the slice. Default: 0.
-        end_mask (int): Ending index of the slice. Default: 0.
-        ellipsis_mask (int): An int mask. Default: 0.
-        new_axis_mask (int): An int mask. Default: 0.
-        shrink_axis_mask (int): An int mask. Default: 0.
+        begin_mask (int): Starting index of the slice. Default: ``0`` .
+        end_mask (int): Ending index of the slice. Default: ``0`` .
+        ellipsis_mask (int): An int mask. Default: ``0`` .
+        new_axis_mask (int): An int mask. Default: ``0`` .
+        shrink_axis_mask (int): An int mask. Default: ``0`` .
 
     Inputs:
         - **input_x** (Tensor) - The input Tensor.
@@ -3113,10 +3418,30 @@ class StridedSlice(PrimitiveWithInfer):
 
     Refer to :func:`mindspore.ops.strided_slice` for more details.
 
+    Args:
+        begin_mask (int, optional): Starting index of the slice. Default: ``0`` .
+        end_mask (int, optional): Ending index of the slice. Default: ``0`` .
+        ellipsis_mask (int, optional): An int mask, ignore slicing operation when set to 1. Default: ``0`` .
+        new_axis_mask (int, optional): An int mask for adding new dims. Default: ``0`` .
+        shrink_axis_mask (int, optional): An int mask for shrinking dims. Default: ``0`` .
+
+    Inputs:
+        - **input_x** (Tensor) - The input Tensor to be extracted from.
+        - **begin** (tuple[int]) - A tuple which represents the location where to start.
+        - **end** (tuple[int]) - A tuple or which represents the maximum location where to end.
+        - **strides** (tuple[int]) - A tuple which represents the strides is continuously added
+          before reaching the maximum location. Only int is allowed, it can be negative
+          which results in reversed slicing.
+
+    Outputs:
+        Tensor, return the extracts a strided slice of a Tensor based on `begin/end` index and `strides`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor([[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]],
         ...                   [[5, 5, 5], [6, 6, 6]]], mindspore.float32)
         >>> #         [[[1. 1. 1.]
@@ -3127,7 +3452,7 @@ class StridedSlice(PrimitiveWithInfer):
         >>> #
         >>> #          [[5. 5. 5.]
         >>> #           [6. 6. 6.]]]
-        >>> # In order to visually view the multi-dimensional array, write the above as follows：
+        >>> # In order to visually view the multi-dimensional array, write the above as follows
         >>> #         [
         >>> #             [
         >>> #                 [1,1,1]
@@ -3218,10 +3543,10 @@ class StridedSlice(PrimitiveWithInfer):
         end_v, end_len = self._check_and_get_value(end, 'end')
         strides_v, strides_len = self._check_and_get_value(strides, 'strides')
 
-        is_dynamic_tuple = (self._is_none_in_tuple(begin_v['value'])
-                            or self._is_none_in_tuple(end_v['value'])
-                            or self._is_none_in_tuple(strides_v['value']))
-        is_dynamic = None in (begin_v['value'], end_v['value'], strides_v['value'])
+        is_dynamic_tuple = (self._is_none_in_tuple(begin_v.get('value'))
+                            or self._is_none_in_tuple(end_v.get('value'))
+                            or self._is_none_in_tuple(strides_v.get('value')))
+        is_dynamic = None in (begin_v.get('value'), end_v.get('value'), strides_v.get('value'))
 
         if not is_dynamic and (begin_len != strides_len or end_len != strides_len):
             raise ValueError(
@@ -3341,8 +3666,7 @@ class StridedSlice(PrimitiveWithInfer):
             strides_value = strides_v['shape_value']
         return begin_value, end_value, strides_value
 
-    @staticmethod
-    def _is_none_in_tuple(x):
+    def _is_none_in_tuple(self, x):
         return isinstance(x, tuple) and None in x
 
     def _compute_slicing_length(self, begin, end, stride, x_dim):
@@ -3569,10 +3893,17 @@ class Diag(PrimitiveWithCheck):
 
     Refer to :func:`mindspore.ops.diag` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The input tensor.
+
+    Outputs:
+        Tensor, has the same dtype as the `input_x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor([1, 2, 3, 4]).astype('int32')
         >>> diag = ops.Diag()
         >>> output = diag(input_x)
@@ -3602,9 +3933,9 @@ class DiagPart(PrimitiveWithCheck):
 
     Extracts the diagonal elements from the given Tensor.
 
-    If the input_x is a Tensor of shape :math:`[D_1,..., D_k, D_1,..., D_k]`, then the
+    If the `input_x` is a Tensor of shape :math:`[D_1,..., D_k, D_1,..., D_k]`, then the
     output will be a Tensor of rank k of shape :math:`[D_1,..., D_k]` where:
-    :math:`output[i_1,..., i_k] = input_x[i_1,..., i_k, i_1,..., i_k]`.
+    :math:`output[i_1,..., i_k] = input\_x[i_1,..., i_k, i_1,..., i_k]`.
 
     Inputs:
         - **input_x** (Tensor) - The rank of input tensor is 2k(k > 0).
@@ -3654,10 +3985,25 @@ class Mvlgamma(Primitive):
 
     Refer to :func:`mindspore.ops.mvlgamma` for more details.
 
+    Args:
+        p(int): The number of dimensions. And the value of `p` must be greater than or equal to 1.
+
+    Inputs:
+        - **x** (Tensor) - The tensor to compute the multivariate log-gamma function,
+          which must be one of the following types: float32, float64.
+          The shape is :math:`(N,*)`, where :math:`*` means any number of additional dimensions.
+          And the value of any element in `x` must be greater than :math:`(p - 1) / 2`.
+
+    Outputs:
+        Tensor, has the same shape and type as `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[3, 4, 5], [4, 2, 6]]), mindspore.float32)
         >>> op = ops.Mvlgamma(p=3)
         >>> y = op(x)
@@ -3684,8 +4030,7 @@ class Eye(Primitive):
         - **n** (int) - The number of rows of returned tensor. Constant value only.
         - **m** (int) - The number of columns of returned tensor. Constant value only.
         - **t** (mindspore.dtype) - MindSpore's dtype, the data type of the returned tensor.
-          The data type can be bool or Number.
-          Default: None, the data type of the returned tensor is mindspore.float32.
+          Default: ``None`` , the data type of the returned tensor is mindspore.float32.
 
     Outputs:
         Tensor, a tensor with ones on the diagonal and the rest of elements are zero. The shape of `output` depends on
@@ -3695,6 +4040,8 @@ class Eye(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
         >>> eye = ops.Eye()
         >>> output = eye(2, 2, mindspore.int32)
         >>> print(output)
@@ -3719,17 +4066,29 @@ class ScatterNd(Primitive):
     r"""
     Scatters a tensor into a new tensor depending on the specified indices.
 
-    The following figure shows the calculation process of inserting two slices in the first dimension of a rank-3
-    with two matrices of new values:
+    Refer to :func:`mindspore.ops.scatter_nd` for more details.
 
-    .. image:: ScatterNd.png
+    Inputs:
+        - **indices** (Tensor) - The index of scattering in the new tensor with int32 or int64 data type.
+          The rank of indices must be at least 2 and `indices_shape[-1] <= len(shape)`.
+        - **updates** (Tensor) - The source Tensor to be scattered.
+          It has shape `indices_shape[:-1] + shape[indices_shape[-1]:]`.
+        - **shape** (tuple[int]) - Define the shape of the output tensor, has the same data type as indices.
+          The shape of `shape` is :math:`(x_1, x_2, ..., x_R)`, and the length of 'shape' is greater than or equal to 2.
+          In other words, the shape of `shape` is at least :math:`(x_1, x_2)`.
+          And the value of any element in `shape` must be greater than or equal to 1.
+          In other words, :math:`x_1` >= 1, :math:`x_2` >= 1.
 
-    Refer to :func:`mindspore.ops.scatter_nd` for more details.
+    Outputs:
+        Tensor, the new tensor, has the same type as `update` and the same shape as `shape`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> op = ops.ScatterNd()
         >>> indices = Tensor(np.array([[0], [2]]), mindspore.int32)
         >>> updates = Tensor(np.array([[[1, 1, 1, 1], [2, 2, 2, 2],
@@ -3803,7 +4162,7 @@ class ResizeNearestNeighbor(Primitive):
     Args:
         size (Union[tuple, list]): The target size. The dimension of size must be 2.
         align_corners (bool): Whether the centers of the 4 corner pixels of the input
-                              and output tensors are aligned. Default: False.
+                              and output tensors are aligned. Default: ``False`` .
 
     Inputs:
         - **input_x** (Tensor) - The input tensor. The shape of the tensor is :math:`(N, C, H, W)`.
@@ -3851,33 +4210,24 @@ class ResizeNearestNeighborV2(Primitive):
     values of neighboring points at all, yielding a piecewise-constant interpolant.
 
     Args:
-        align_corners (bool, optional): If true, the centers of the 4 corner pixels of the input and output
-            tensors are aligned, preserving the values at the corner pixels. Defaults: False.
-        half_pixel_centers (bool, optional): Whether half pixel center. If set to True,
-            `align_corners` should be False. Default: False.
-        data_format (str, optional): An optional `string` that describes the
-            format of the input `x`. Default: `NHWC`.
+        align_corners (bool, optional): If ``True`` , the centers of the 4 corner pixels of the input and output
+            tensors are aligned, preserving the values at the corner pixels. Default: ``False`` .
+        half_pixel_centers (bool, optional): Whether half pixel center. If set to ``True`` ,
+            `align_corners` should be False. Default: ``False`` .
 
     Inputs:
-        - **x** (Tensor) - 4-D with shape :math:`(batch, height, width, channels)`
-          or :math:`(batch, channels, height, width)` depending on the attr 'data_format'. Support
-          type [`int8`, `uint8`, `int16`, `uint16`, `int32`, `int64`, `float16`, `float32`, `float64`].
+        - **x** (Tensor) - 4-D with shape :math:`(batch, channels, height, width)` .
         - **size** (Tensor) - The new size for the images. A 1-D int32 Tensor
           of 2 elements: [`new_height, new_width`].
 
     Outputs:
         - **y** (Tensor) - The resized images. A 4-D with shape
-          :math:`(batch, new\_height, new\_width, channels)`
-          or :math:`(batch, channels, new\_height, new\_width)`
-          depending on the attr `data_format`. It has the same dtype as `x`.
+          :math:`(batch, channels, new\_height, new\_width)`. It has the same dtype as `x`.
 
     Raises:
         TypeError: If `x` or `size` is not a Tensor.
-        TypeError: If the data type  of `x` is not in supported list.
         TypeError: If the data type  of `size` is not int32.
         TypeError: If `align_corners` or `half_pixel_centers` is not bool.
-        TypeError: If `data_format` is not string.
-        ValueError: If `data_format` not in [`NHWC`, `NCHW`].
         ValueError: If any value of `size` is non positive.
         ValueError: If the dimension of `x` is not 4.
         ValueError: If the dimension of `size` is not 1.
@@ -3888,29 +4238,26 @@ class ResizeNearestNeighborV2(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> input_tensor = Tensor(np.ones((1, 4, 4, 1)), mstype.float32)
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
+        >>> input_tensor = Tensor(np.ones((1, 1, 4, 4)), mstype.float32)
         >>> size = Tensor([2, 2], mstype.int32)
         >>> resize = ops.ResizeNearestNeighborV2()
         >>> output = resize(input_tensor, size)
         >>> print(output)
-        [[[[1.]
-           [1.]]
-          [[1.]
-           [1.]]]]
+        [[[[1. 1.]
+           [1. 1.]]]]
         >>> print(output.shape)
-        (1, 2, 2, 1)
+        (1, 1, 2, 2)
     """
 
     @prim_attr_register
-    def __init__(self, align_corners=False, half_pixel_centers=False, data_format='NHWC'):
+    def __init__(self, align_corners=False, half_pixel_centers=False):
         """Initialize ResizeNearestNeighborV2"""
         self.init_prim_io_names(inputs=['x', 'size'], outputs=['y'])
-
         validator.check_bool(align_corners, 'align_corners', self.name)
         validator.check_bool(half_pixel_centers, 'half_pixel_centers', self.name)
-        validator.check_value_type('data_format', data_format, [str], self.name)
-        self.format = validator.check_string(data_format, ['NHWC', 'NCHW'], 'data_format', self.name)
-        self.add_prim_attr('data_format', self.format)
 
 
 class GatherNd(Primitive):
@@ -3919,10 +4266,20 @@ class GatherNd(Primitive):
 
     Refer to :func:`mindspore.ops.gather_nd` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The target tensor to gather values.
+        - **indices** (Tensor) - The index tensor, with int32 or int64 data type.
+
+    Outputs:
+        Tensor, has the same type as `input_x` and the shape is indices_shape[:-1] + x_shape[indices_shape[-1]:].
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> op = ops.GatherNd()
         >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
         >>> indices = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
@@ -3953,11 +4310,11 @@ class ScatterUpdate(Primitive):
     the relatively highest priority data type.
 
     Args:
-        use_locking (bool): Whether to protect the assignment by a lock. Default: True.
+        use_locking (bool): Whether to protect the assignment by a lock. Default: ``True`` .
 
     Inputs:
         - **input_x** (Parameter) - The target tensor, with data type of Parameter.
-          The shape is :math:`(N, *)` where :math:`*` means,any number of additional dimensions.
+          The shape is 0-D or :math:`(N, *)` where :math:`*` means any number of additional dimensions.
         - **indices** (Tensor) - The index of input tensor. With int32 data type.
           If there are duplicates in indices, the order for updating is undefined.
         - **updates** (Tensor) - The tensor to update the input tensor, has the same type as input,
@@ -3977,6 +4334,9 @@ class ScatterUpdate(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> np_x = np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]])
         >>> input_x = mindspore.Parameter(Tensor(np_x, mindspore.float32), name="x")
         >>> indices = Tensor(np.array([0, 1]), mindspore.int32)
@@ -4022,11 +4382,11 @@ class ScatterNdUpdate(Primitive):
     the relatively highest priority data type.
 
     Args:
-        use_locking (bool): Whether to protect the assignment by a lock. Default: True.
+        use_locking (bool): Whether to protect the assignment by a lock. Default: ``True`` .
 
     Inputs:
         - **input_x** (Parameter) - The target tensor, with data type of Parameter.
-          The shape is :math:`(N, *)` where :math:`*` means,any number of additional dimensions.
+          The shape is :math:`(N, *)` where :math:`*` means any number of additional dimensions.
         - **indices** (Tensor) - The index of input tensor, with int32 or int64 data type.
         - **updates** (Tensor) - N-D(2D or 3D) Tensor The tensor to be updated to the input tensor,
           has the same type as input. The shape is `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
@@ -4044,6 +4404,9 @@ class ScatterNdUpdate(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> np_x = np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]])
         >>> input_x = mindspore.Parameter(Tensor(np_x, mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
@@ -4081,7 +4444,7 @@ class ScatterMax(_ScatterOpDynamic):
     .. math::
 
         \text{input_x}[\text{indices}[i, ..., j], :]
-        = max(\text{input_x}[\text{indices}[i, ..., j], :], \text{updates}[i, ..., j, :])
+        = \max(\text{input_x}[\text{indices}[i, ..., j], :], \text{updates}[i, ..., j, :])
 
     Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent.
     If they have different data types, the lower priority data type will be converted to
@@ -4089,11 +4452,11 @@ class ScatterMax(_ScatterOpDynamic):
     when `updates` does not support conversion to the data type required by `input_x`.
 
     Args:
-        use_locking (bool): Whether to protect the assignment by a lock. Default: False.
+        use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
         - **input_x** (Parameter) - The target tensor, with data type of Parameter.
-          The shape is :math:`(N, *)` where :math:`*` means,any number of additional dimensions.
+          The shape is :math:`(N, *)` where :math:`*` means any number of additional dimensions.
         - **indices** (Tensor) - The index to do max operation whose data type must be mindspore.int32 or
           mindspore.int64.
         - **updates** (Tensor) - The tensor that performs the maximum operation with `input_x`,
@@ -4115,6 +4478,9 @@ class ScatterMax(_ScatterOpDynamic):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]), mindspore.float32),
         ...                     name="input_x")
         >>> indices = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
@@ -4139,7 +4505,7 @@ class ScatterMin(_ScatterOpDynamic):
     .. math::
 
         \text{input_x}[\text{indices}[i, ..., j], :]
-        = min(\text{input_x}[\text{indices}[i, ..., j], :], \text{updates}[i, ..., j, :])
+        = \min(\text{input_x}[\text{indices}[i, ..., j], :], \text{updates}[i, ..., j, :])
 
     Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent.
     If they have different data types, the lower priority data type will be converted to
@@ -4147,11 +4513,11 @@ class ScatterMin(_ScatterOpDynamic):
     when `updates` does not support conversion to the data type required by `input_x`.
 
     Args:
-        use_locking (bool): Whether to protect the assignment by a lock. Default: False.
+        use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
         - **input_x** (Parameter) - The target tensor, with data type of Parameter.
-          The shape is :math:`(N, *)` where :math:`*` means,any number of additional dimensions.
+          The shape is :math:`(N, *)` where :math:`*` means any number of additional dimensions.
         - **indices** (Tensor) - The index to do min operation whose data type must be mindspore.int32 or
           mindspore.int64.
         - **updates** (Tensor) - The tensor doing the min operation with `input_x`,
@@ -4173,6 +4539,9 @@ class ScatterMin(_ScatterOpDynamic):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([[0.0, 1.0, 2.0], [0.0, 0.0, 0.0]]), mindspore.float32),
         ...                     name="input_x")
         >>> indices = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
@@ -4207,12 +4576,11 @@ class ScatterAdd(Primitive):
 
     Args:
         use_locking (bool): Whether to protect the assignment by a lock.
-            If true, `input_x` will be protected by the lock.
-            Otherwise, the calculation result is undefined. Default: False.
+            If ``True`` , `input_x` will be protected by the lock.
+            Otherwise, the calculation result is undefined. Default: ``False`` .
 
     Inputs:
         - **input_x** (Parameter) - The target tensor, with data type of Parameter.
-          The shape is :math:`(N, *)` where :math:`*` means,any number of additional dimensions.
         - **indices** (Tensor) - The index to do min operation whose data type must be mindspore.int32 or
           mindspore.int64.
         - **updates** (Tensor) - The tensor doing the min operation with `input_x`,
@@ -4232,6 +4600,9 @@ class ScatterAdd(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[0, 1], [1, 1]]), mindspore.int32)
         >>> updates = Tensor(np.ones([2, 2, 3]), mindspore.float32)
@@ -4324,7 +4695,7 @@ class ScatterSub(Primitive):
     the relatively highest priority data type.
 
     Args:
-        use_locking (bool): Whether to protect the assignment by a lock. Default: False.
+        use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
         - **input_x** (Parameter) - The target tensor, with data type of Parameter.
@@ -4348,6 +4719,9 @@ class ScatterSub(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[0, 1]]), mindspore.int32)
         >>> updates = Tensor(np.array([[[1.0, 1.0, 1.0], [2.0, 2.0, 2.0]]]), mindspore.float32)
@@ -4429,12 +4803,15 @@ class Triu(Primitive):
     The upper triangular section of the matrix comprises of the
     elements present on and above the main diagonal.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Args:
-        diagonal (int, optional): The index of diagonal. Default: 0, indicating the main diagonal.
+        diagonal (int, optional): The index of diagonal. Default: ``0`` , indicating the main diagonal.
 
     Inputs:
-        - **x** (Tensor) - The input tensor with shape :math:`(N, *)`
-          where :math:`*` means any number of additional dimensions. The data type is Number.
+        - **x** (Tensor) - The input tensor with shape :math:`(M, N, *)`
+          where :math:`*` means any number of additional dimensions.
 
     Outputs:
         - **y** (Tensor) - A tensor has the same shape and data type as input.
@@ -4442,12 +4819,14 @@ class Triu(Primitive):
     Raises:
         TypeError: If `x` is not an Tensor.
         TypeError: If `diagonal` is not an int.
-        ValueError: If length of shape of x is less than 1.
+        ValueError: If the dimension of `input` is less than 2.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[ 1,  2,  3,  4],
         ...                      [ 5,  6,  7,  8],
         ...                      [10, 11, 12, 13],
@@ -4509,11 +4888,11 @@ class ScatterMul(_ScatterOpDynamic):
     the relatively highest priority data type.
 
     Args:
-        use_locking (bool): Whether to protect the assignment by a lock. Default: False.
+        use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
         - **input_x** (Parameter) - The target tensor, with data type of Parameter.
-          The shape is :math:`(N, *)` where :math:`*` means,any number of additional dimensions.
+          The shape is :math:`(N, *)` where :math:`*` means any number of additional dimensions.
         - **indices** (Tensor) - The index to do multiply operation whose data type must be mstype.int32 or
           mstype.int64.
         - **updates** (Tensor) - The tensor doing the multiply operation with `input_x`,
@@ -4533,6 +4912,9 @@ class ScatterMul(_ScatterOpDynamic):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([[1.0, 1.0, 1.0], [2.0, 2.0, 2.0]]), mstype.float32), name="x")
         >>> indices = Tensor(np.array([0, 1]), mstype.int32)
         >>> updates = Tensor(np.array([[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]), mstype.float32)
@@ -4614,11 +4996,11 @@ class ScatterDiv(_ScatterOpDynamic):
     when `updates` does not support conversion to the data type required by `input_x`.
 
     Args:
-        use_locking (bool): Whether to protect the assignment by a lock. Default: False.
+        use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
         - **input_x** (Parameter) - The target tensor, with data type of Parameter.
-          The shape is :math:`(N, *)` where :math:`*` means,any number of additional dimensions.
+          The shape is :math:`(N, *)` where :math:`*` means any number of additional dimensions.
         - **indices** (Tensor) - The index to do divide operation whose data type must be mstype.int32 or
           mstype.int64.
         - **updates** (Tensor) - The tensor doing the divide operation with `input_x`,
@@ -4640,6 +5022,9 @@ class ScatterDiv(_ScatterOpDynamic):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([[6.0, 6.0, 6.0], [2.0, 2.0, 2.0]]), mstype.float32), name="x")
         >>> indices = Tensor(np.array([0, 1]), mstype.int32)
         >>> updates = Tensor(np.array([[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]), mstype.float32)
@@ -4714,10 +5099,27 @@ class ScatterNdAdd(Primitive):
 
     Refer to :func:`mindspore.ops.scatter_nd_add` for more details.
 
+    Args:
+        use_locking (bool, optional): Whether to protect the assignment by a lock. Default: ``False`` .
+
+    Inputs:
+        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+          The shape is :math:`(N, *)` where :math:`*` means any number of additional dimensions.
+        - **indices** (Tensor) - The index to do add operation whose data type must be mindspore.int32.
+          The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
+        - **updates** (Tensor) - The tensor doing the add operation with `input_x`,
+          the data type is same as `input_x`, the shape is `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
+
+    Outputs:
+        Tensor, the updated `input_x`, has the same shape and type as `input_x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
         >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
@@ -4774,10 +5176,27 @@ class ScatterNdSub(Primitive):
 
     Refer to :func:`mindspore.ops.scatter_nd_sub` for more details.
 
+    Args:
+        use_locking (bool, optional): Whether to protect the assignment by a lock. Default: ``False`` .
+
+    Inputs:
+        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+          The shape is :math:`(N, *)` where :math:`*` means any number of additional dimensions.
+        - **indices** (Tensor) - The index to do sub operation whose data type must be mindspore.int32.
+          The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
+        - **updates** (Tensor) - The tensor doing the sub operation with `input_x`,
+          the data type is same as `input_x`, the shape is `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
+
+    Outputs:
+        Tensor, the updated `input_x`, has the same shape and type as `input_x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
         >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
@@ -4838,10 +5257,26 @@ class ScatterNdMul(_ScatterNdOp):
 
     Refer to :func:`mindspore.ops.scatter_nd_mul` for more details.
 
+    Args:
+        use_locking (bool, optional): Whether to protect the assignment by a lock. Default: ``False`` .
+
+    Inputs:
+        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+        - **indices** (Tensor) - The index to do mul operation whose data type must be int32 or int64.
+          The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
+        - **updates** (Tensor) - The tensor to do the mul operation with `input_x`.
+          The data type is same as `input_x`, and the shape is `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
+
+    Outputs:
+        Tensor, the updated `input_x`, has the same shape and type as `input_x`.
+
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
         >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
@@ -4887,10 +5322,26 @@ class ScatterNdDiv(_ScatterNdOp):
 
     Refer to :func:`mindspore.ops.scatter_nd_div` for more details.
 
+    Args:
+        use_locking (bool, optional): Whether to protect the assignment by a lock. Default: ``False`` .
+
+    Inputs:
+        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+        - **indices** (Tensor) - The index to do div operation whose data type must be int32 or int64.
+          The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
+        - **updates** (Tensor) - The tensor to do the div operation with `input_x`.
+          The data type is same as `input_x`, and the shape is `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
+
+    Outputs:
+        Tensor, the updated `input_x`, has the same shape and type as `input_x`.
+
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
         >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
@@ -4936,10 +5387,26 @@ class ScatterNdMax(_ScatterNdOp):
 
     Refer to :func:`mindspore.ops.scatter_nd_max` for more details.
 
+    Args:
+        use_locking (bool, optional): Whether to protect the assignment by a lock. Default: ``False`` .
+
+    Inputs:
+        - **input_x** (Parameter) -The target tensor, with data type of Parameter.
+        - **indices** (Tensor) - The index to do maximum operation whose data type must be int32 or int64.
+          The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
+        - **updates** (Tensor) - The tensor to do the max operation with `input_x`.
+          The data type is same as `input_x`, and the shape is `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
+
+    Outputs:
+        Tensor, the updated `input_x`, has the same shape and type as `input_x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
         >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
@@ -4987,10 +5454,26 @@ class ScatterNdMin(_ScatterNdOp):
 
     Refer to :func:`mindspore.ops.scatter_nd_min` for more details.
 
+    Args:
+        use_locking (bool, optional): Whether to protect the assignment by a lock. Default: ``False`` .
+
+    Inputs:
+        - **input_x** (Parameter) -The target tensor, with data type of Parameter.
+        - **indices** (Tensor) - The index to do minimum operation whose data type must be int32 or int64.
+          The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
+        - **updates** (Tensor) - The tensor to do the max operation with `input_x`.
+          The data type is same as `input_x`, and the shape is `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
+
+    Outputs:
+        Tensor, the updated `input_x`, has the same shape and type as `input_x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.ones(8) * 10, mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
         >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
@@ -5031,59 +5514,6 @@ class ScatterNdMin(_ScatterNdOp):
         super().__init__(use_locking)
 
 
-class ScatterNonAliasingAdd(Primitive):
-    """
-    Applies sparse addition to the input using individual values or slices.
-
-    Using given values to update tensor value through the add operation, along with the input indices.
-    This operation outputs the `input_x` after the update is done, which makes it convenient to use the updated value.
-
-    Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent.
-    If they have different data types, the lower priority data type will be converted to
-    the relatively highest priority data type.
-
-    Inputs:
-        - **input_x** (Parameter) - The target parameter. The data type must be float16, float32 or int32.
-        - **indices** (Tensor) - The index to perform the addition operation whose data type must be mindspore.int32.
-        - **updates** (Tensor) - The tensor that performs the addition operation with `input_x`,
-          the data type is the same as `input_x`, the shape is `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-
-    Outputs:
-        Parameter, the updated `input_x`.
-
-    Raises:
-        TypeError: If dtype of `indices` is not int32.
-        TypeError: If dtype of `input_x` is not one of float16, float32, int32.
-        ValueError: If the shape of `updates` is not equal to `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> input_x = Parameter(Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8]), mindspore.float32), name="x")
-        >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
-        >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
-        >>> scatter_non_aliasing_add = ops.ScatterNonAliasingAdd()
-        >>> output = scatter_non_aliasing_add(input_x, indices, updates)
-        >>> print(output)
-        [ 1. 10.  9.  4. 12.  6.  7. 17.]
-    """
-
-    __mindspore_signature__ = (
-        sig.make_sig('input_x', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
-        sig.make_sig('indices', dtype=sig.sig_dtype.T1),
-        sig.make_sig('updates', dtype=sig.sig_dtype.T)
-    )
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize ScatterNonAliasingAdd"""
-        self.init_prim_io_names(inputs=['input_x', 'indices', 'updates'], outputs=['y'])
-        self.add_prim_attr('side_effect_mem', True)
-
-
 class SpaceToDepth(Primitive):
     r"""
     Rearrange blocks of spatial data into depth.
@@ -5116,6 +5546,9 @@ class SpaceToDepth(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.random.rand(1,3,2,2), mindspore.float32)
         >>> block_size = 2
         >>> space_to_depth = ops.SpaceToDepth(block_size)
@@ -5169,6 +5602,9 @@ class DepthToSpace(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.random.rand(1, 12, 1, 1), mindspore.float32)
         >>> block_size = 2
         >>> depth_to_space = ops.DepthToSpace(block_size)
@@ -5297,6 +5733,9 @@ class BatchToSpace(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> block_size = 2
         >>> crops = [[0, 0], [0, 0]]
         >>> batch_to_space = ops.BatchToSpace(block_size, crops)
@@ -5437,59 +5876,42 @@ class SpaceToBatchND(Primitive):
         self.paddings = paddings
 
 
-class BatchToSpaceND(Primitive):
+class BatchToSpaceNDV2(Primitive):
     r"""
-    `ops.BatchToSpaceND` is deprecated from version 2.0 and will be removed in a future version,
-    use `ops.batch_to_space_nd` instead.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> block_size = 2
-        >>> crops = [[0, 0], [0, 0]]
-        >>> batch_to_space = ops.BatchToSpaceND(block_size, crops)
-        >>> input_x = Tensor(np.array([[[[1]]], [[[2]]], [[[3]]], [[[4]]]]), mindspore.float32)
-        >>> output = batch_to_space(input_x)
-        >>> print(output)
-        [[[[1.  2.]
-           [3.  4.]]]]
-    """
-
-    @deprecated("2.0", "ops.batch_to_space_nd", False)
-    @prim_attr_register
-    def __init__(self, block_shape, crops):
-        """Initialize BatchToSpaceND"""
-        if isinstance(block_shape, int):
-            block_shape = (block_shape,) * np.array(crops).shape[0]
-        self.add_prim_attr("block_shape", block_shape)
-        validator.check_value_type('block_shape type', block_shape, [list, tuple], self.name)
-        validator.check('block_shape shape', len(np.array(block_shape).shape), '', 1, validator.EQ, self.name)
-        block_rank = len(block_shape)
-        if context.get_context("device_target") == "Ascend":
-            validator.check('block_shape length', block_rank, '', 2, validator.EQ, self.name)
-        for elem in block_shape:
-            validator.check('block_shape element', elem, '', 1, validator.GE, self.name)
-            validator.check_value_type('block_shape element', elem, [int], self.name)
-        self.block_shape = block_shape
+    Divides batch dimension with blocks and interleaves these blocks back into spatial dimensions.
 
-        validator.check_value_type('crops type', crops, [list, tuple], self.name)
-        validator.check('crops length', len(crops), '', 1, validator.GE, self.name)
-        validator.check('crops shape', np.array(crops).shape, '', (block_rank, 2), validator.EQ, self.name)
-        for elem in itertools.chain(*crops):
-            validator.check_non_negative_int(elem, 'crops element', self.name)
-            validator.check_value_type('crops element', elem, [int], self.name)
-        self.crops = crops
+    Refer to :func:`mindspore.ops.batch_to_space_nd` for more details.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
-class BatchToSpaceNDV2(Primitive):
-    r"""
-    Divides batch dimension with blocks and interleaves these blocks back into spatial dimensions.
+    Inputs:
+        - **input_x** (Tensor) - The input tensor. It must be greater or equal to 2-D
+          tensor(equal to 4-D tensor on Ascend), batch dimension must be divisible by product of `block_shape`.
+        - **block_shape** (Tensor) - The block shape of dividing block with all value greater
+          than or equal to 1. If `block_shape` is a tuple or list, the length of `block_shape` is M corresponding
+          to the number of spatial dimensions. If `block_shape` is an int, the block size of M dimensions are the
+          same, equal to `block_shape`. In this case of Ascend, M must be 2.
+        - **crops** (Union[list(int), tuple(int)]) - The crops values for spatial dimensions, containing
+          M subtraction list. Each contains 2 integer values. All values must be >= 0. crops[i] specifies
+          the crops values for spatial dimension i, which corresponds to input dimension i + offset,
+          where offset = N-M, and N is the number of input dimensions. It is required that
+          :math:`input\_shape[i+offset]*block\_shape[i] > crops[i][0]+crops[i][1]`
 
-    Refer to :func:`mindspore.ops.batch_to_space_nd` for more details.
+    Outputs:
+        Tensor, contains the result of batch division and rearrangement of the original Tensor.
 
     Supported Platforms:
         ``Ascend``
+
+    Examples:
+        >>> block_shape = Tensor(np.array([2, 2]), mindspore.int32)
+        >>> crops = [[0, 0], [0, 0]]
+        >>> input_x = Tensor(np.array([[[[1]]], [[[2]]], [[[3]]], [[[4]]]]), mindspore.float32)
+        >>> output = ops.BatchToSpaceNDV2(input_x, block_shape, crops)
+        >>> print(output)
+        [[[[1.  2.]
+           [3.  4.]]]]
     """
 
     @prim_attr_register
@@ -5505,10 +5927,22 @@ class BroadcastTo(PrimitiveWithCheck):
 
     Refer to :func:`mindspore.ops.broadcast_to` for more details.
 
+    Args:
+        shape (tuple): The target shape to broadcast. Can be fully specified, or have -1 in one position
+            where it will be substituted by the input tensor's shape in that position, see example.
+
+    Inputs:
+        - **input_x** (Tensor) - The input tensor of any dimension.
+
+    Outputs:
+        Tensor, with the given `shape` and the same data type as `input_x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> shape = (2, 3)
         >>> x = Tensor(np.array([1, 2, 3]).astype(np.float32))
         >>> output = ops.BroadcastTo(shape=shape)(x)
@@ -5547,12 +5981,13 @@ class Meshgrid(PrimitiveWithInfer):
     Refer to :func:`mindspore.ops.meshgrid` for more details.
 
     Args:
-        indexing (str, optional): Cartesian ('xy', default) or
+        indexing (str, optional): Cartesian ('xy') or
             matrix ('ij') indexing of output. Valid options: xy' or 'ij'. In the 2-D case with
-            inputs of length `M` and `N`, the outputs are of shape `(N, M)`
-            for 'xy' indexing and `(M, N)` for 'ij' indexing. In the 3-D
+            inputs of length `M` and `N`, the outputs are of shape :math:`(N, M)`
+            for 'xy' indexing and :math:`(M, N)` for 'ij' indexing. In the 3-D
             case with inputs of length `M`, `N` and `P`, outputs are of shape
-            `(N, M, P)` for 'xy' indexing and `(M, N, P)` for 'ij' indexing.
+            :math:`(N, M, P)` for 'xy' indexing and :math:`(M, N, P)` for 'ij' indexing.
+            Default: 'xy'.
 
     Inputs:
         - **input** (Union[tuple]) - A Tuple of N 1-D Tensor objects.
@@ -5565,6 +6000,8 @@ class Meshgrid(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1, 2, 3, 4]).astype(np.int32))
         >>> y = Tensor(np.array([5, 6, 7]).astype(np.int32))
         >>> z = Tensor(np.array([8, 9, 0, 1, 2]).astype(np.int32))
@@ -5634,7 +6071,7 @@ class Meshgrid(PrimitiveWithInfer):
         return out_shape
 
     def infer_dtype(self, x_type):
-        validator.check_subclass("input[0]", x_type[0], mstype.tensor, self.name)
+        validator.check_subclass("input[0]", x_type[0], mstype.tensor_type, self.name)
         n = len(x_type)
         for i in range(1, n):
             validator.check('x_type[%d]' % i, x_type[i], 'base', x_type[0], validator.EQ, self.name, TypeError)
@@ -5642,12 +6079,12 @@ class Meshgrid(PrimitiveWithInfer):
 
 
 class ReverseSequence(PrimitiveWithInfer):
-    """
+    r"""
     Reverses variable length slices.
 
     Args:
         seq_dim (int): The dimension where reversal is performed. Required.
-        batch_dim (int): The input is sliced in this dimension. Default: 0.
+        batch_dim (int): The input is sliced in this dimension. Default: ``0`` .
 
     Inputs:
         - **x** (Tensor) - The input to reverse, supporting all number types including bool.
@@ -5658,12 +6095,20 @@ class ReverseSequence(PrimitiveWithInfer):
 
     Raises:
         TypeError: If `seq_dim` or `batch_dim` is not an int.
-        ValueError: If value of `batch_dim` is equal to or greater than length of shape of `x` .
+        ValueError: If :math:`len(seq\_lengths) != x.shape[batch\_dim]`.
+        ValueError: If :math:`batch\_dim == seq\_dim`.
+        ValueError: If :math:`seq\_dim < 0` or :math:`seq\_dim >= len(x.shape)`.
+        ValueError: If :math:`batch\_dim < 0` or :math:`batch\_dim >= len(x.shape)`.
+        RuntimeError: If any value of `seq_lengths` is less than 0.
+        RuntimeError: If any value of `seq_lengths` is larger than `x.shape[seq_dim]`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), mindspore.float32)
         >>> seq_lengths = Tensor(np.array([1, 2, 3]))
         >>> reverse_sequence = ops.ReverseSequence(seq_dim=1)
@@ -5741,7 +6186,7 @@ class EditDistance(Primitive):
         calling this API.
 
     Args:
-        normalize (bool): If true, edit distances are normalized by length of truth. Default: True.
+        normalize (bool): If ``True`` , edit distances are normalized by length of truth. Default: ``True`` .
 
     Inputs:
         - **hypothesis_indices** (Tensor) - The indices of the hypothesis list SparseTensor. With int64 data type.
@@ -5798,7 +6243,6 @@ class EditDistance(Primitive):
     def __init__(self, normalize=True):
         """Initialize EditDistance"""
         self.normalize = validator.check_value_type("normalize", normalize, [bool], self.name)
-        self.set_const_input_indexes([2, 5])
 
 
 class TransShape(PrimitiveWithInfer):
@@ -5837,12 +6281,13 @@ class Sort(Primitive):
         Using Float32 might cause loss of accuracy.
 
     Args:
-        axis (int): The dimension to sort along. Default: -1.
-        descending (bool): Controls the sort order. If descending is True then the elements
-            are sorted in descending order by value. Default: False.
+        axis (int, optional): The dimension to sort along. Default: ``-1``, means the last dimension.
+            The Ascend backend only supports sorting the last dimension.
+        descending (bool, optional): Controls the sort order. If descending is ``True`` then the elements
+            are sorted in descending order by value. Default: ``False`` .
 
     Inputs:
-        - **x** (Tensor) - The input tensor of any dimension, with a type of float16 or float32.
+        - **x** (Tensor) - The input tensor.
 
     Outputs:
         - **y1** (Tensor) - A tensor whose values are the sorted values, with the same shape and data type as input.
@@ -5851,13 +6296,15 @@ class Sort(Primitive):
     Raises:
         TypeError: If `axis` is not an int.
         TypeError: If `descending` is not a bool.
-        TypeError: If dtype of `x` is neither float16 nor float32.
         ValueError: If `axis` is not in range of [-len(x.shape), len(x.shape)).
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), mindspore.float16)
         >>> sort = ops.Sort()
         >>> output = sort(x)
@@ -5880,7 +6327,7 @@ class Sort(Primitive):
         self.init_prim_io_names(inputs=['x'], outputs=['y1', 'y2'])
 
 
-class EmbeddingLookup(PrimitiveWithCheck):
+class EmbeddingLookup(Primitive):
     """
     Returns a slice of input tensor based on the specified indices.
 
@@ -5908,6 +6355,9 @@ class EmbeddingLookup(PrimitiveWithCheck):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_params = Tensor(np.array([[8, 9], [10, 11], [12, 13], [14, 15]]), mindspore.float32)
         >>> input_indices = Tensor(np.array([[5, 2], [8, 5]]), mindspore.int32)
         >>> offset = 4
@@ -5927,19 +6377,6 @@ class EmbeddingLookup(PrimitiveWithCheck):
                                 outputs=['output'])
         self.add_prim_attr('bprop_return_sparse', True)
 
-    def __check__(self, params, indices, offset):
-        validator.check_subclass("params", params['dtype'], mstype.tensor, self.name)
-        validator.check_tensor_dtype_valid("indices", indices['dtype'], mstype.int_type, self.name)
-        validator.check_subclass("offset", offset['dtype'], mstype.int_, self.name)
-        indices_shp = indices['shape']
-        if not indices_shp:
-            raise ValueError(f"For '{self.name}', the dimension of 'input_indices' should not "
-                             f"be zero, but got {len(indices_shp)}.")
-        params_shp = params['shape']
-        if len(params_shp) > 2:
-            raise ValueError(f"For '{self.name}', the dimension of 'input_params' must <= 2, "
-                             f"but got {len(params_shp)}.")
-
 
 class GatherD(Primitive):
     """
@@ -5947,10 +6384,22 @@ class GatherD(Primitive):
 
     Refer to :func:`mindspore.ops.gather_elements` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input tensor.
+        - **dim** (int) - The axis along which to index. It must be int32 or int64.
+        - **index** (Tensor) - The indices of elements to gather. It can be one of the following data types:
+          int32, int64. The value range of each index element is [-x_rank[dim], x_rank[dim]).
+
+    Outputs:
+        Tensor, has the same data type with `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[1, 2], [3, 4]]), mindspore.int32)
         >>> index = Tensor(np.array([[0, 0], [1, 0]]), mindspore.int32)
         >>> dim = 1
@@ -5968,25 +6417,10 @@ class GatherD(Primitive):
 
 class Identity(Primitive):
     """
-    Returns a Tensor with the same shape and contents as input.
-
-    Inputs:
-        - **x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`. The data type is Number.
-
-    Outputs:
-        Tensor, the shape of tensor and the data type are the same as `input_x`, :math:`(x_1, x_2, ..., x_R)`.
-
-    Raises:
-        TypeError: If `x` is not a Tensor.
+    The `mindspore.ops.Identity` interface is deprecated, please use the :func:`mindspore.ops.deepcopy` instead.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> x = Tensor(np.array([1, 2, 3, 4]), mindspore.int64)
-        >>> output = ops.Identity()(x)
-        >>> print(output)
-        [1 2 3 4]
+        Deprecated
     """
 
     @prim_attr_register
@@ -6041,17 +6475,14 @@ class Range(PrimitiveWithCheck):
 
     Args:
         maxlen (int, optional): Memory that can fit `maxlen` many elements
-            will be allocated for the output. Optional, must be positive, defaults to 1000000.
+            will be allocated for the output. Optional, must be positive. Default: 1000000.
             If the output has more than `maxlen` elements, a runtime error
             will occur.
 
     Inputs:
-        - **start** (Tensor) - A scalar Tensor. The first number in the sequence. Must have
-          type: int32 ,int64, float32 or float64.
-        - **limit** (Tensor) - A scalar Tensor. Upper limit of the sequence, exclusive. Must
-          have type: int32 ,int64, float32 or float64.
-        - **delta** (Tensor) - A scalar Tensor. Number that increments `start`. Must have
-          type: int32 ,int64, float32 or float64.
+        - **start** (Tensor) - A scalar Tensor. The first number in the sequence.
+        - **limit** (Tensor) - A scalar Tensor. Upper limit of the sequence, exclusive.
+        - **delta** (Tensor) - A scalar Tensor. Number that increments `start`.
 
     Outputs:
        A 1-D Tensor, with the same type as the inputs.
@@ -6060,6 +6491,8 @@ class Range(PrimitiveWithCheck):
         ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> start = Tensor(0, mstype.int32)
         >>> limit = Tensor(10, mstype.int32)
         >>> delta = Tensor(4, mstype.int32)
@@ -6166,10 +6599,21 @@ class MaskedFill(Primitive):
 
     Refer to :func:`mindspore.ops.masked_fill` for more details.
 
+    Inputs:
+        - **input** (Tensor) - The input Tensor.
+        - **mask** (Tensor[bool]) - The boolean mask.
+        - **value** (Union[float, Tensor]) - The value to fill in with, which dtype is the same as `input`.
+
+    Outputs:
+        Tensor, has the same type and shape as `input`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input = Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
         >>> mask = Tensor(np.array([True, True, False, True]), mindspore.bool_)
         >>> output = ops.MaskedFill()(input, mask, 0.5)
@@ -6184,17 +6628,20 @@ class MaskedFill(Primitive):
 
 class MaskedScatter(Primitive):
     """
-    Updates the value in the input with the updates value according to the mask.
-    The shapes of `mask` and `x` must be the same or broadcastable.
+    Updates the value in the input with value in `updates` according to the `mask`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Inputs:
-        - **x** (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-        - **mask** (Tensor[bool]): A bool tensor with a shape broadcastable to x.
-        - **updates** (Tensor): A tensor with the same data type as x. The
+        - **x** (Tensor): The input Tensor to be updated.
+        - **mask** (Tensor[bool]): The mask Tensor indicating which elements should be modified or replaced.
+          The shapes of `mask` and `x` must be the same or broadcastable.
+        - **updates** (Tensor): The values to scatter into the target tensor `x`. It has the same data type as `x`. The
           number of elements must be greater than or equal to the number of True's in `mask`.
 
     Outputs:
-        Tensor, with the same type and shape as x.
+        Tensor, with the same type and shape as `x`.
 
     Raises:
         TypeError: If `x`, `mask` or `updates` is not a Tensor.
@@ -6202,16 +6649,19 @@ class MaskedScatter(Primitive):
         TypeError: If dtype of `mask` is not bool.
         TypeError: If the dim of `x` less than the dim of `mask`.
         ValueError: If `mask` can not be broadcastable to `x`.
-        ValueError: If the number of elements in `updates` is less than the number required for the updates.
+        ValueError: If the number of elements in `updates` is less than number of True's in `mask`.
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend`` ``CPU``
 
     Examples:
-        >>> x= Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input_x = Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
         >>> mask = Tensor(np.array([True, True, False, True]), mindspore.bool_)
         >>> updates = Tensor(np.array([5., 6., 7.]), mindspore.float32)
-        >>> output = ops.MaskedScatter()(input_X, mask, updates)
+        >>> output = ops.MaskedScatter()(input_x, mask, updates)
         >>> print(output)
         [5. 6. 3. 7.]
     """
@@ -6228,8 +6678,8 @@ class MaskedSelect(PrimitiveWithCheck):
     The shapes of the `mask` tensor and the `x` tensor don't need to match, but they must be broadcastable.
 
     Inputs:
-        - **x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-        - **mask** (Tensor[bool]) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        - **x** (Tensor) - Input Tensor of any dimension.
+        - **mask** (Tensor[bool]) - Boolean mask Tensor, has the same shape as `x`.
 
     Outputs:
         A 1-D Tensor, with the same type as x.
@@ -6242,11 +6692,19 @@ class MaskedSelect(PrimitiveWithCheck):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1, 2, 3, 4]), mindspore.int32)
         >>> mask = Tensor(np.array([1, 0, 1, 0]), mindspore.bool_)
         >>> output = ops.MaskedSelect()(x, mask)
         >>> print(output)
         [1 3]
+        >>> x = Tensor(2.1, mindspore.float32)
+        >>> mask = Tensor(True, mindspore.bool_)
+        >>> output = ops.MaskedSelect()(x, mask)
+        >>> print(output)
+        [2.1]
     """
 
     @prim_attr_register
@@ -6273,9 +6731,9 @@ class SearchSorted(Primitive):
 
     Args:
         dtype (:class:`mindspore.dtype`, optional): Output data type. An optional data type of
-            `mstype.int32` and `mstype.int64`. Default: `mstype.int64`.
-        right (bool, optional): Search Strategy. If True, return the last suitable index found;
-            if False, return the first such index. Default: False.
+            ``mstype.int32`` and ``mstype.int64``. Default: ``mstype.int64``.
+        right (bool, optional): Search Strategy. If ``True`` , return the last suitable index found;
+            if ``False`` , return the first such index. Default: ``False`` .
 
     Inputs:
         - **sorted_sequence** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R-1, x_R)` or `(x_1)`.
@@ -6292,6 +6750,9 @@ class SearchSorted(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> sorted_sequence = Tensor(np.array([[0, 1, 3, 5, 7], [2, 4, 6, 8, 10]]), mindspore.float32)
         >>> values = Tensor(np.array([[3, 6, 9], [3, 6, 9]]), mindspore.float32)
         >>> output = ops.SearchSorted()(sorted_sequence, values)
@@ -6358,7 +6819,7 @@ class _TensorScatterOp(PrimitiveWithInfer):
 
 
 class TensorScatterUpdate(_TensorScatterOp):
-    """
+    r"""
     Creates a new tensor by updating the positions in `input_x` indicated by
     `indices`, with values from `update`. This operation is almost equivalent to using
     `mindspore.ops.ScatterNdUpdate` , except that the updates are applied on `input_x` instead of a zero tensor.
@@ -6374,14 +6835,17 @@ class TensorScatterUpdate(_TensorScatterOp):
     are multiple index vectors in `indices` that correspond to the same position, the
     value of that position in the output will be nondeterministic.
 
+    .. math::
+        output[indices] = update
+
     Inputs:
-        - **input_x** (Tensor) - The target tensor. The dimension of input_x must be no less than indices.shape[-1].
+        - **input_x** (Tensor) - The input tensor. The dimension of input_x must be no less than indices.shape[-1].
           The shape is :math:`(N, *)` where :math:`*` means,any number of additional dimensions.
           The data type is Number.
         - **indices** (Tensor) - The index of input tensor whose data type is int32 or int64.
           The rank must be at least 2.
-        - **update** (Tensor) - The tensor to update the input tensor, has the same type as input, and
-          :math:`update.shape = indices.shape[:-1]+input_x.shape[indices.shape[-1]:]`
+        - **update** (Tensor) - The tensor to update the input tensor, has the same type as `input_x`, and
+          :math:`update.shape = indices.shape[:-1]+input\_x.shape[indices.shape[-1]:]`
 
     Outputs:
         Tensor, has the same shape and type as `input_x`.
@@ -6396,6 +6860,9 @@ class TensorScatterUpdate(_TensorScatterOp):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
         >>> indices = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
         >>> update = Tensor(np.array([1.0, 2.2]), mindspore.float32)
@@ -6452,10 +6919,23 @@ class TensorScatterMax(Primitive):
 
     Refer to :func:`mindspore.ops.tensor_scatter_max` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The target tensor. The dimension of input_x must be no less than indices.shape[-1].
+        - **indices** (Tensor) - The index of input tensor whose data type is int32 or int64.
+          The rank must be at least 2.
+        - **updates** (Tensor) - The tensor to update the input tensor, has the same type as input,
+          and updates.shape should be equal to indices.shape[:-1] + input_x.shape[indices.shape[-1]:].
+
+    Outputs:
+        Tensor, has the same shape and type as `input_x`.
+
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
         >>> indices = Tensor(np.array([[0, 0], [0, 0]]), mindspore.int32)
         >>> updates = Tensor(np.array([1.0, 2.2]), mindspore.float32)
@@ -6487,10 +6967,23 @@ class TensorScatterMin(Primitive):
 
     Refer to :func:`mindspore.ops.tensor_scatter_min` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The target tensor. The dimension of input_x must be no less than indices.shape[-1].
+        - **indices** (Tensor) - The index of input tensor whose data type is int32 or int64.
+          The rank must be at least 2.
+        - **updates** (Tensor) - The tensor to update the input tensor, has the same type as input,
+          and updates.shape should be equal to indices.shape[:-1] + input_x.shape[indices.shape[-1]:].
+
+    Outputs:
+        Tensor, has the same shape and type as `input_x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
         >>> indices = Tensor(np.array([[0, 0], [0, 0]]), mindspore.int32)
         >>> updates = Tensor(np.array([1.0, 2.2]), mindspore.float32)
@@ -6516,18 +7009,35 @@ class TensorScatterMin(Primitive):
 
 
 class TensorScatterSub(Primitive):
-    """
+    r"""
     Creates a new tensor by subtracting the values from the positions in `input_x` indicated by
     `indices`, with values from `updates`. When multiple values are provided for the same
     index, the result of the update will be to subtract these values respectively. This operation is almost
     equivalent to using :class:`mindspore.ops.ScatterNdSub` , except that the updates are applied on output `Tensor`
     instead of input `Parameter`.
+
+    .. math::
+        output[indices] = input\_x - update
+
     Refer to :func:`mindspore.ops.tensor_scatter_sub` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The target tensor. The dimension of input_x must be no less than indices.shape[-1].
+        - **indices** (Tensor) - The index of input tensor whose data type is int32 or int64.
+          The rank must be at least 2.
+        - **updates** (Tensor) - The tensor to update the input tensor, has the same type as `input_x`,
+          and the shape of `updates` should be equal to :math:`indices.shape[:-1] + input\_x.shape[indices.shape[-1]:]`.
+
+    Outputs:
+        Tensor, has the same shape and type as `input_x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
         >>> indices = Tensor(np.array([[0, 0], [0, 0]]), mindspore.int32)
         >>> updates = Tensor(np.array([1.0, 2.2]), mindspore.float32)
@@ -6562,10 +7072,23 @@ class TensorScatterAdd(Primitive):
 
     Refer to :func:`mindspore.ops.tensor_scatter_add` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The target tensor. The dimension of input_x must be no less than indices.shape[-1].
+        - **indices** (Tensor) - The index of input tensor whose data type is int32 or int64.
+          The rank must be at least 2.
+        - **updates** (Tensor) - The tensor to update the input tensor, has the same type as input,
+          and updates. Shape should be equal to indices.shape[:-1] + input_x.shape[indices.shape[-1]:].
+
+    Outputs:
+        Tensor, has the same shape and type as `input_x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
         >>> indices = Tensor(np.array([[0, 0], [0, 0]]), mindspore.int32)
         >>> updates = Tensor(np.array([1.0, 2.2]), mindspore.float32)
@@ -6591,18 +7114,34 @@ class TensorScatterAdd(Primitive):
 
 
 class TensorScatterMul(_TensorScatterOp):
-    """
+    r"""
     Creates a new tensor by multiplying the values from the positions in `input_x` indicated by
     `indices`, with values from `updates`. When multiple values are provided for the same
     index, the result of the update will be to multiply these values respectively.
     The updates are applied on output `Tensor` instead of input `Parameter`.
 
+    .. math::
+        output[indices] = input\_x \times update
+
     Refer to :func:`mindspore.ops.tensor_scatter_mul` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The target tensor. The dimension of input_x must be no less than indices.shape[-1].
+        - **indices** (Tensor) - The index of input tensor whose data type is int32 or int64.
+          The rank must be at least 2.
+        - **updates** (Tensor) - The tensor to update the input tensor, has the same type as `input_x`,
+          and the shape of `updates` should be equal to indices.shape[:-1] + input_x.shape[indices.shape[-1]:].
+
+    Outputs:
+        Tensor, has the same shape and type as `input_x`.
+
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
         >>> indices = Tensor(np.array([[0, 0], [0, 0]]), mindspore.int32)
         >>> updates = Tensor(np.array([1.0, 2.2]), mindspore.float32)
@@ -6636,10 +7175,23 @@ class TensorScatterDiv(_TensorScatterOp):
 
     Refer to :func:`mindspore.ops.tensor_scatter_div` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - The target tensor. The dimension of input_x must be no less than indices.shape[-1].
+        - **indices** (Tensor) - The index of input tensor whose data type is int32 or int64.
+          The rank must be at least 2.
+        - **updates** (Tensor) - The tensor to update the input tensor, has the same type as input,
+          and updates.shape should be equal to indices.shape[:-1] + input_x.shape[indices.shape[-1]:].
+
+    Outputs:
+        Tensor, has the same shape and type as `input_x`.
+
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
         >>> indices = Tensor(np.array([[0, 0], [0, 0]]), mindspore.int32)
         >>> updates = Tensor(np.array([1.0, 2.0]), mindspore.float32)
@@ -6677,8 +7229,8 @@ class ListDiff(Primitive):
 
     Args:
         out_idx (:class:`mindspore.dtype`, optional): The dtype of `idx`,
-            an optioanal datatype of `mstype.int32` and `mstype.int64`.
-            Default: `mstype.int32`.
+            an optioanal datatype of ``mstype.int32`` and ``mstype.int64`` .
+            Default: ``mstype.int32`` .
 
     Inputs:
         - **x** - Values to keep. A 1-D `Tensor`.
@@ -6810,7 +7362,9 @@ class SplitV(Primitive):
 
 class TensorScatterElements(Primitive):
     """
-    Updates the value of the input Tensor through specified reduction operation.
+    Write all elements in `updates` to the index specified by `indices` in `input_x` according to the reduction
+    operation specified by `reduction`.
+    `axis` controls the direction of the scatter operation.
 
     Refer to :func:`mindspore.ops.tensor_scatter_elements` for more details.
 
@@ -6818,10 +7372,32 @@ class TensorScatterElements(Primitive):
         If there are multiple index vectors in `indices` that correspond to the same position,
         the value of that position in the output will be nondeterministic.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        axis (int, optional): Specify which axis to do scatter operation. Default: ``0`` .
+        reduction (str, optional): Which reduction operation to scatter, default is ``"none"`` . Other option: "add".
+
+    Inputs:
+        - **data** (Tensor) - The target tensor. Its rank must be at least 1.
+        - **indices** (Tensor) - The index of `input_x` to do scatter operation whose data type must be int32 or
+          int64. It has the same rank as `data`. And accepted range is [-s, s) where s is the size along axis.
+        - **updates** (Tensor) - The tensor doing the scatter operation with `data`,
+          it has the same shape and type as `data`.
+        - **update** (Tensor) - The tensor doing the scatter operation with `data`,
+          it has the same type as `data` and the same shape as `indices`.
+
+    Outputs:
+        Tensor, has the same shape and type as `data`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import mindspore.ops as ops
+        >>> from mindspore import Tensor
         >>> op = ops.TensorScatterElements(0, "none")
         >>> data = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), mindspore.float32)
         >>> indices = Tensor(np.array([[1, 0, 2], [0, 2, 1]]), mindspore.int32)
@@ -6831,9 +7407,12 @@ class TensorScatterElements(Primitive):
         [[ 0.0  0.0  3.0]
          [ 0.0  5.0  0.0]
          [ 7.0  0.0  0.0]]
+        >>> import mindspore as ms
+        >>> import mindspore.ops as ops
+        >>> from mindspore import Tensor
         >>> op = ops.TensorScatterElements(1, "add")
-        >>> data = Tensor(np.array([[1, 2, 3, 4, 5]), mindspore.float32)
-        >>> indices = Tensor(np.array([[2, 4]), mindspore.int32)
+        >>> data = Tensor(np.array([[1, 2, 3, 4, 5]]), mindspore.float32)
+        >>> indices = Tensor(np.array([[2, 4]]), mindspore.int32)
         >>> updates = Tensor(np.array([[8, 8]]), mindspore.float32)
         >>> output = op(data, indices, updates)
         >>> print(output)
@@ -6849,7 +7428,8 @@ class TensorScatterElements(Primitive):
         self.init_prim_io_names(inputs=['data', 'indices', 'updates'], outputs=['y'])
         target = context.get_context("device_target")
         if reduction != 'none' and target.lower() == "ascend":
-            raise ValueError(f"Currently Ascend device_target only support `reduction`='none', "
+            raise ValueError(f"For '{self.name}', "
+                             f"Currently Ascend device_target only support `reduction`='none', "
                              f"but got {reduction}")
 
 
@@ -6858,6 +7438,9 @@ class ExtractVolumePatches(Primitive):
     Extract patches from input and put them in the "depth" output dimension.
     "depth" dimension is the second dim of output.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Args:
         kernel_size (Union[int, tuple[int], list[int]]): A list of ints which's length is 3 or 5.
             The size of the sliding window for each dimension of input. Must be: :math:`[1, 1, k_d, k_h, k_w]` or
@@ -6865,10 +7448,10 @@ class ExtractVolumePatches(Primitive):
         strides (Union[int, tuple[int], list[int]]): A list of ints which's length is 3 or 5.
             How far the centers of two consecutive patches are in input. Must be: :math:`[1, 1, s_d, s_h, s_w]` or
             :math:`[s_d, s_h, s_w]`. If :math:`s_d = s_h = s_w`, you can enter an integer.
-        padding (str): A string from: "SAME", "VALID". The type of padding algorithm to use.
+        padding (str): A string from: ``"SAME"`` , ``"VALID"`` . The type of padding algorithm to use.
 
     Inputs:
-        - **input_x** (Tensor) - A Tensor. 5-D Tensor with shape :math:`()`.
+        - **input_x** (Tensor) - A Tensor. 5-D Tensor with shape :math:`(x_n, x_c, x_d, x_h, x_w)`.
 
     Outputs:
         Tensor, has the same type as input.
@@ -6882,7 +7465,7 @@ class ExtractVolumePatches(Primitive):
         TypeError: If padding is not str.
         ValueError: If the length of kernel_size is neither 3 nor 5 and kernel_size is not an integer.
         ValueError: If the length of strides is neither 3 nor 5 and strides is not an integer.
-        ValueError: If padding is neither "VALID" nor "SAME".
+        ValueError: If padding is neither ``"VALID"`` nor ``"SAME"`` .
         ValueError: If elements of kernel_size or strides are not positive integer.
         ValueError: If input_x is not a tensor in dimension 5.
         ValueError: If input_x's shape has zero.
@@ -6897,10 +7480,13 @@ class ExtractVolumePatches(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> kernel_size = (1, 1, 2, 2, 2)
         >>> strides = (1, 1, 1, 1, 1)
         >>> padding = "VALID"
-        >>> input_x = P.Reshape()(Tensor(np.arange(1, 28), mstype.float16), (1, 1, 3, 3, 3))
+        >>> input_x = ops.Reshape()(Tensor(np.arange(1, 28), mstype.float16), (1, 1, 3, 3, 3))
         >>> output_y = ops.ExtractVolumePatches(kernel_size, strides, padding)(input_x)
         >>> print(output_y.shape)
         (1, 8, 2, 2, 2)
@@ -6994,14 +7580,14 @@ class Lstsq(Primitive):
        \end{array}
 
     Args:
-        fast (bool, optional): Solving algorithm. Default: True.
+        fast (bool, optional): Solving algorithm. Default: ``True`` .
 
             - If `fast` is True, then the solution is computed by solving
               the normal equations using Cholesky decomposition.
             - If `fast` is False, an algorithm based on numerically robust
               completed orthogonal decomposition is used.
 
-        l2_regularizer (float, optional): L2 regularization coefficient. Default: 0.0.
+        l2_regularizer (float, optional): L2 regularization coefficient. Default: ``0.0`` .
 
     Inputs:
         - **x** (Tensor) - :math:`(m \times n)` matrix `x`. The input tensor whose data type is
@@ -7050,8 +7636,8 @@ class LowerBound(Primitive):
 
     Args:
         out_type (:class:`mindspore.dtype`, optional): An optional data type of
-            `mindspore.dtype.int32` and `mindspore.dtype.int64`.
-            Default: `mindspore.dtype.int32`.
+            ``mindspore.dtype.int32`` and ``mindspore.dtype.int64`` .
+            Default: ``mindspore.dtype.int32`` .
 
     Inputs:
         - **sorted_x** (Tensor) - The input tensor whose dtype is real number and
@@ -7106,8 +7692,8 @@ class UpperBound(Primitive):
 
     Args:
         out_type (:class:`mindspore.dtype`, optional): Specified output type.
-            Supported types: `mindspore.dtype.int32` and `mindspore.dtype.int64`.
-            Default: `mindspore.dtype.int32`.
+            Supported types: ``mindspore.dtype.int32`` and ``mindspore.dtype.int64`` .
+            Default: ``mindspore.dtype.int32`` .
 
     Inputs:
         - **sorted_x** (Tensor) - The input tensor whose dtype is real number. The rank must be 2.
@@ -7158,6 +7744,16 @@ class Cummax(Primitive):
 
     Refer to :func:`mindspore.ops.cummax` for more details.
 
+    Args:
+        axis (int): The axis to accumulate the tensor's value. Must be in the range [-rank(input), rank(input)).
+
+    Inputs:
+        - **input** (Tensor) - The input tensor.
+
+    Outputs:
+        A tuple of 2 Tensors(values, indices), containing the cumulative maximum of elements and the index,
+        The shape of each output tensor is the same as input `input`.
+
     Supported Platforms:
         ``GPU`` ``CPU``
 
@@ -7206,7 +7802,7 @@ class RightShift(Primitive):
 
     Inputs:
         - **input_x** (Tensor) - The target tensor, will be shifted to the right
-          by `input_y` bits element-wise.
+          by `input_y` bits element-wise. Support all int and uint types.
         - **input_y** (Tensor) - Number of bits shifted, the tensor must have the same type as `input_x`.
 
     Outputs:
@@ -7220,6 +7816,8 @@ class RightShift(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> rightshift = ops.RightShift()
         >>> input_x = Tensor(np.array([1, 2, 3]).astype(np.uint8))
         >>> input_y = Tensor(np.array([1, 1, 1]).astype(np.uint8))
@@ -7251,11 +7849,10 @@ class LogSpace(Primitive):
         This is an experimental API that is subject to change or deletion.
 
     Args:
-        steps (int, optional): The steps must be a non-negative integer. Default: 10.
-        base (int, optional): The base must be a non-negative integer. Default: 10.
-        dtype (mindspore.dtype, optional): The dtype of output, include mindspore.float16,
-            mindspore.float32 or mindspore.float64. Default: mindspore.float32.
-
+        steps (int, optional): The steps must be a non-negative integer. Default: ``10`` .
+        base (int, optional): The base must be a non-negative integer. Default: ``10`` .
+        dtype (mindspore.dtype, optional): The dtype of output, include ``mstype.float16`` ,
+            ``mstype.float32`` or ``mstype.float64`` . Default: ``mstype.float32`` .
 
     Inputs:
         - **start** (Tensor) - Start value of interval, with shape of 0-D,
@@ -7270,8 +7867,8 @@ class LogSpace(Primitive):
         TypeError: If `input` is not a Tensor.
         TypeError: If `steps` is not an int.
         TypeError: If `base` is not an int.
-        TypeError: If `dtype` is not mindspore.float16, mindspore.float32 or
-            mindspore.float64.
+        TypeError: If `dtype` is not mstype.float16, mstype.float32 or
+            mstype.float64.
         ValueError: If `steps` is not a non-negative integer.
         ValueError: If `base` is not a non-negative integer.
 
@@ -7279,9 +7876,11 @@ class LogSpace(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> logspace = ops.LogSpace(steps = 10, base = 10, dtype=mindspore.float32)
-        >>> start = Tensor(1, mindspore.float32)
-        >>> end = Tensor(10, mindspore.float32)
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
+        >>> logspace = ops.LogSpace(steps = 10, base = 10, dtype=mstype.float32)
+        >>> start = Tensor(1, mstype.float32)
+        >>> end = Tensor(10, mstype.float32)
         >>> output = logspace(start, end)
         >>> print(output)
         [1.e+01 1.e+02 1.e+03 1.e+04 1.e+05 1.e+06 1.e+07 1.e+08 1.e+09 1.e+10]
@@ -7306,6 +7905,12 @@ class NonZero(Primitive):
 
     Refer to :func:`mindspore.ops.nonzero` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input Tensor, its rank should be greater than or eaqual to 1.
+
+    Outputs:
+        - **y** (Tensor), 2-D Tensor of data type int64.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -7345,12 +7950,12 @@ class Tril(Primitive):
         This is an experimental API that is subject to change or deletion.
 
     Args:
-        diagonal (int, optional): An optional attribute indicates the diagonal to consider, default: 0,
+        diagonal (int, optional): An optional attribute indicates the diagonal to consider, default: ``0`` ,
             indicating the main didiagonal.
 
     Inputs:
-        - **x** (Tensor) - A Tensor with shape :math:`(x_1, x_2, ..., x_R)`. The rank must be at least 2.
-          Supporting all number types including bool.
+        - **x** (Tensor) - The input tensor with shape :math:`(M, N, *)`
+          where :math:`*` means any number of additional dimensions.
 
     Outputs:
         Tensor, the same shape and data type as the input `x`.
@@ -7358,13 +7963,14 @@ class Tril(Primitive):
     Raises:
         TypeError: If `x` is not a Tensor.
         TypeError: If `diagonal` is not an int.
-        TypeError: If the type of `x` is neither number nor bool.
         ValueError: If the rank of `x` is less than 2.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[ 1,  2,  3,  4],
         ...                      [ 5,  6,  7,  8],
         ...                      [10, 11, 12, 13],
@@ -7417,10 +8023,23 @@ class IndexFill(Primitive):
 
     Refer to :func:`mindspore.ops.index_fill` for more details.
 
+    Inputs:
+        - **x** (Tensor) - Input tensor.
+        - **dim** (Union[int, Tensor]) - Dimension along which to fill the input tensor. Only supports
+          a 0-dimensional tensor or an int number.
+        - **index** (Tensor) - Indices of the input tensor to fill in.
+        - **value** (Union[bool, int, float, Tensor]) - Value to fill the input tensor.
+
+    Outputs:
+        Tensor, has the same type and shape as input tensor.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> index_fill = ops.IndexFill()
         >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]).astype(np.float32))
         >>> index = Tensor([0, 2], mindspore.int32)
@@ -7440,39 +8059,44 @@ class IndexFill(Primitive):
 
 class IndexPut(Primitive):
     r"""
-    According to the index number of indexes, replace the value corresponding to x1 with the value in x2.
+    According to the index number of `indexes`, replace the value corresponding to `x1` with the value in `x2`.
 
     Args:
         accumulate (int): If accumulate is 1, the elements in x2 are added to x1,
-            else the elements in x2 replace the corresponding element in x1, should be 0 or 1. Default: 0.
+            else the elements in x2 replace the corresponding element in x1, should be 0 or 1. Default: ``0`` .
+
     Inputs:
         - **x1** (Tensor) - The assigned target tensor, 1-D or higher dimensional.
-        - **x2** (Tensor) - 1-D Tensor of the same type as "x1". if size= 1 will be broadcast
+        - **x2** (Tensor) - 1-D Tensor of the same type as `x1`. If the size of `x2` is 1,
+          it will broadcast to the same size as `x1`.
         - **indices** (tuple[Tensor], list[Tensor]) - the indices of type int32 or int64, used to index into x1.
-        The rank of tensors in indices should be 1-D, size of indices should <= x1.rank and the tensors in indices
-        should be broadcastable.
+          The rank of tensors in indices should be 1-D, size of indices should <= x1.rank and the tensors in indices
+          should be broadcastable.
 
     Outputs:
-        The Tensor to be assigned. Should be of the same type and shape as "x1".
+        Tensor, has the same dtype and shape as `x1`.
 
     Raises:
-            TypeError: If the dtype of `x1` is not equal to the dtype of `x2`.
-            TypeError: If the dtype of `indices` is not tuple[Tensor], list[Tensor].
-            TypeError: If the dtype of tensors in `indices` are not int32 or int64.
-            TypeError: If the dtype of tensors in `indices` are inconsistent.
-            TypeError: If the dtype of `accumulate` are not int.
-            ValueError: If rank(x2) is not 1-D.
-            ValueError: If size(x2) is not 1 or max size of the tensors in `indices` when rank(x1) == size(indices).
-            ValueError: If size(x2) is not 1 or x1.shape[-1] when rank(x1) > size(indices).
-            ValueError: If the rank of tensors in `indices` is not 1-D.
-            ValueError: If the tensors in `indices` is not be broadcastable.
-            ValueError: If size(indices) > rank(x1).
-            ValueError: If `accumulate` is not equal to 0 or 1.
+        TypeError: If the dtype of `x1` is not equal to the dtype of `x2`.
+        TypeError: If `indices` is not tuple[Tensor] or list[Tensor].
+        TypeError: If the dtype of tensors in `indices` are not int32 or int64.
+        TypeError: If the dtype of tensors in `indices` are inconsistent.
+        TypeError: If the dtype of `accumulate` are not int.
+        ValueError: If rank(x2) is not 1-D.
+        ValueError: If size(x2) is not 1 or max size of the tensors in `indices` when rank(x1) == size(indices).
+        ValueError: If size(x2) is not 1 or x1.shape[-1] when rank(x1) > size(indices).
+        ValueError: If the rank of tensors in `indices` is not 1-D.
+        ValueError: If the tensors in `indices` is not be broadcastable.
+        ValueError: If size(indices) > rank(x1).
+        ValueError: If `accumulate` is not equal to 0 or 1.
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x1 = Tensor(np.array([[1, 2, 3], [4, 5, 6]]).astype(np.int32))
         >>> x2 = Tensor(np.array([3]).astype(np.int32))
         >>> indices = [Tensor(np.array([0, 0]).astype(np.int32)), Tensor(np.array([0, 1]).astype(np.int32))]
@@ -7671,15 +8295,15 @@ class LeftShift(Primitive):
         This is an experimental API that is subject to change or deletion.
 
     Inputs:
-        - **x1** (Tensor) - The target tensor whose dtype supports int8, int16, int32, int64,
-          uint8, uint16, uint32, uint64, will be shifted to the left by x2 in element-wise.
-        - **x2** (Tensor) - The tensor must have the same dtype as x1. And the tensor must have the same shape as x1
-          or could be broadcast with x1.
+        - **x1** (Tensor) - The target tensor whose dtype supports all int and uint type,
+          will be shifted to the left by `x2` in element-wise.
+        - **x2** (Tensor) - The tensor must have the same dtype as `x1`.
+          And the tensor must have the same shape as `x1` or could be broadcast with `x1`.
 
     Outputs:
-        - **output** (Tensor) - The output tensor, has the same dtype as x1.
-          And the shape of the output tensor is the same shape as x1, or the same shape
-          as x1 and x2 after broadcasting.
+        - **output** (Tensor) - The output tensor, has the same dtype as `x1`.
+          And the shape of the output tensor is the same shape as `x1`, or the same shape
+          as `x1` and `x2` after broadcasting.
 
     Raises:
         TypeError: If `x1` or `x2` has wrong type.
@@ -7690,12 +8314,14 @@ class LeftShift(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> left_shift = ops.LeftShift()
         >>> x1 = Tensor(np.array([1, 2, 3]).astype(np.int8))
         >>> x2 = Tensor(np.array([0, 1, -1]).astype(np.int8))
         >>> output = left_shift(x1, x2)
         >>> print(output)
-        [1 4 3]
+        [1 4 0]
     """
 
     @prim_attr_register
@@ -7710,22 +8336,23 @@ class FillDiagonal(Primitive):
     The input has at least 2 dimensions, and all dimensions of input must be equal in length
     when the dimension of input is greater than 2.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Args:
         fill_value (float): The value to fill the diagonal of `input_x`.
         wrap (bool, optional): Controls whether the diagonal elements continue onto the
             remaining rows in case of a tall matrix(A matrix has more rows than columns).
-            Examples blow demonstrates how it works on a tall matrix if `wrap` is set True.
-            Default: False.
+            Examples blow demonstrates how it works on a tall matrix if `wrap` is set ``True`` .
+            Default: ``False`` .
 
     Inputs:
         - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-          The data type must be float32, int32 or int64.
 
     Outputs:
         - **y** (Tensor) - Tensor, has the same shape and data type as the input `input_x`.
 
     Raises:
-        TypeError: If data type of `input_x` is not one of the following: float32, int32, int64.
         ValueError: If the dimension of `input_x` is not greater than 1.
         ValueError: If the size of each dimension is not equal, when the dimension is greater than 2.
 
@@ -7733,6 +8360,8 @@ class FillDiagonal(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]).astype(np.float32))
         >>> fill_value = 9.9
         >>> fill_diagonal = ops.FillDiagonal(fill_value)
@@ -7792,16 +8421,16 @@ class HammingWindow(Primitive):
 
     Args:
         periodic (bool, optional): a flag determines whether the returned window trims off
-            the last duplicate value from the symmetric window. Default: True.
+            the last duplicate value from the symmetric window. Default: ``True`` .
 
             - If True, returns a window to be used as periodic function, in above formula,
               :math:`N = \text{length} + 1`.
             - If False, return a symmetric window, :math:`N = \text{length}`.
 
-        alpha (float, optional): The coefficient :math:`\alpha` in the equation above. Default: 0.54.
-        beta (float, optional): The coefficient :math:`\beta` in the equation above. Default: 0.46.
-        dtype (:class:`mindspore.dtype`, optional): An optional data type of `mstype.float16`,
-            `mstype.float32` and `mstype.float64`. Default: `mstype.float32`.
+        alpha (float, optional): The coefficient :math:`\alpha` in the equation above. Default: ``0.54`` .
+        beta (float, optional): The coefficient :math:`\beta` in the equation above. Default: ``0.46`` .
+        dtype (:class:`mindspore.dtype`, optional): An optional data type of ``mstype.float16`` ,
+            ``mstype.float32`` and ``mstype.float64`` . Default: ``mstype.float32``.
 
     Inputs:
         - **length** (Tensor) - a positive integer tensor controlling the returned window size, must be 1D.
@@ -7823,6 +8452,8 @@ class HammingWindow(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> # case 1: periodic=True.
         >>> length = Tensor(np.array([6]).astype(np.int32))
         >>> hamming_window = ops.HammingWindow(periodic=True)
@@ -7864,10 +8495,29 @@ class AffineGrid(Primitive):
 
     Refer to :func:`mindspore.ops.affine_grid` for more details.
 
+    Args:
+        align_corners (bool, optional): Geometrically, each pixel of input is viewed as a squqre instead of dot.
+            If True, consider extremum -1 and 1 referring to the centers of the pixels rather than pixel corners.
+            The default value is ``False`` , extremum -1 and 1 refer to the corners of the pixels, so that sampling is
+            irrelevant to resolution of the image. Default: ``False`` .
+
+    Inputs:
+        - **theta** (Tensor) - The input tensor of flow field whose dtype is float16, float32.
+          Input batch of affine matrices with shape :math:`(N, 2, 3)` for 2D grid or :math:`(N, 3, 4)` for 3D grid.
+        - **output_size** (tuple[int]) - The target output image size.
+          The value of target output with format :math:`(N, C, H, W)` for 2D grid
+          or :math:`(N, C, D, H, W)` for 3D grid.
+
+    Outputs:
+        Tensor, a tensor whose data type is same as 'theta', and the shape is :math:`(N, H, W, 2)` for 2D grid
+        or :math:`(N, D, H, W, 3)` for 3D grid.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> affinegrid = ops.AffineGrid(align_corners=False)
         >>> theta = Tensor([[[0.8, 0.5, 0],[-0.5, 0.8, 0]]], mindspore.float32)
         >>> out_size = (1, 3, 2, 3)
@@ -8008,10 +8658,19 @@ class PopulationCount(Primitive):
 
     Refer to :func:`mindspore.ops.population_count` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - Tensor of any dimension. The data type must be int16 or uint16 (Ascend).
+          The data type must be int8, int16, int32, int64, uint8, uint16, uint32, uint64 (CPU and GPU).
+
+    Outputs:
+        Tensor, with the same shape as the input, and the data type is uint8.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor([0, 1, 3], mindspore.int16)
         >>> output = ops.PopulationCount()(input_x)
         >>> print(output)
@@ -8047,12 +8706,17 @@ class TopK(Primitive):
     If the two compared elements are the same, the one with the smaller index value is returned first.
 
     Args:
-        sorted (bool, optional): If True, the obtained elements will be sorted by the values in descending order.
-            If False, the obtained elements will not be sorted. Default: True.
+        sorted (bool, optional): If ``True`` , the obtained elements will be sorted by the values in descending order.
+            If ``False`` , the obtained elements will not be sorted. Default: ``True`` .
 
     Inputs:
-        - **input_x** (Tensor) - Input to be computed, data type must be float16, float32 or int32 on CPU,
-          and float16 or float32 on GPU.
+        - **input_x** (Tensor) - Input to be computed, 0-D input is supported on GPU, but not on Ascend or CPU.
+          supported dtypes:
+
+          - Ascend: int8, uint8, int32, int64, float16, float32.
+          - GPU: float16, float32.
+          - CPU: all numeric types.
+
         - **k** (int) - The number of top elements to be computed along the last dimension, constant input is needed.
 
     Outputs:
@@ -8065,7 +8729,7 @@ class TopK(Primitive):
         TypeError: If `sorted` is not a bool.
         TypeError: If `input_x` is not a Tensor.
         TypeError: If `k` is not an int.
-        TypeError: If dtype of `input_x` is not one of the following: float16, float32 or int32.
+        TypeError: If dtype of `input_x` is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -8119,6 +8783,9 @@ class Bincount(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> array = Tensor(np.array([1, 2, 2, 3, 3, 3, 4, 4, 4, 4]), mindspore.int32)
         >>> size = Tensor(5, mindspore.int32)
         >>> weights = Tensor(np.array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), mindspore.float32)
@@ -8141,6 +8808,17 @@ class CountNonZero(Primitive):
 
     Refer to :func:`mindspore.ops.count_nonzero` for more details.
 
+    Args:
+        dims (Union[int, tuple(int), list(int)], optional): The dimensions to reduce.
+            Default: ``None`` , reduce over all dimensions.
+
+    Inputs:
+        - **x** (Tensor) - Input data is used to count non-zero numbers. With shape
+          :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
+
+    Outputs:
+          Tensor, number of nonzero element across axis specified by `dims`.
+
     Supported Platforms:
         ``Ascend`` ``CPU``