mindspore 2.0.0a0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/ops/operations/array_ops.py

@@ -15,7 +15,6 @@
 
 """Operators for array."""
 import copy
-import functools
 import itertools
 import numbers
 
@@ -28,8 +27,7 @@ from mindspore.ops import signature as sig
 from mindspore.ops._utils import get_broadcast_shape
 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._checkparam import Rel
-from mindspore._checkparam import Validator as validator
+from mindspore import _checkparam as validator
 from mindspore._checkparam import _check_3d_int_or_tuple
 from mindspore.common import dtype as mstype
 from mindspore.common._decorator import deprecated
@@ -76,19 +74,19 @@ class _ScatterOp(PrimitiveWithInfer):
 
 class UnravelIndex(Primitive):
     """
-    Converts an array of flat indices into a tuple of coordinate arrays.
+    Transforms an array consisting of flattened indices into a tuple that contains coordinate arrays.
 
     Inputs:
-        - **indices** (Tensor) - Input Tensor whose elements are indices converting into
-          the flattened version of an array of dimensions dims.
+        - **indices** (Tensor) - The input Tensor, containing indices that will be transformed
+          into the flattened form of an array with dimensions specified by `dims`.
           The dimension of `indices` must be 0-D or 1-D.
           Must be one of the following types: int32, int64.
         - **dims** (Tensor) - The shape of the array to use for unraveling indices.
           The dimension of `dims` must be 1-D. Must have the same type as `indices`.
 
     Outputs:
-        - **y** (Tensor) - Has the same type as `indices`.
-          The dimension of `y` can be 2-D or 1-D(if `indices` is 0D).
+        - **y** (Tensor) - Tensor, it should be 2-D or 1-D(if `indices` is 0D)
+          and has the same type as `indices`.
 
     Raises:
         TypeError: If the data type of `indices` and `dims` are different.
@@ -97,7 +95,7 @@ class UnravelIndex(Primitive):
         ValueError: If `indices` contains negative elements.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> indices = Tensor(np.array([2, 5]), mindspore.int32)
@@ -159,7 +157,7 @@ class _ScatterNdOp(_ScatterOp):
 
     def _check_scatter_shape(self, x_shape, indices_shape, updates_shape, prim_name):
         validator.check('the dimension of x', len(x_shape),
-                        'the dimension of indices', indices_shape[-1], Rel.GE)
+                        'the dimension of indices', indices_shape[-1], validator.GE)
         if indices_shape[:-1] + x_shape[indices_shape[-1]:] != updates_shape:
             raise ValueError(f"For '{prim_name}', updates_shape = "
                              f"indices_shape[:-1] + x_shape[indices_shape[-1]:], but got x_shape: {x_shape}, "
@@ -176,7 +174,10 @@ def _check_infer_attr_reduce(axis, keep_dims, prim_name):
 
 class Expand(Primitive):
     """
-    Returns a new view of the self tensor with singleton dimensions expanded to a larger size.
+    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.
 
@@ -236,7 +237,7 @@ class DType(Primitive):
     Returns the data type of the input tensor as mindspore.dtype.
 
     Inputs:
-        - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        - **input_x** (Tensor) - Input Tensor.
 
     Outputs:
         mindspore.dtype, the data type of a tensor.
@@ -267,17 +268,17 @@ class DType(Primitive):
 
 class CheckNumerics(Primitive):
     """
-    Checks a tensor for NaN and Inf values.
+    Checks a tensor for NaN and Inf values. A runtime error is raised if input has NaN or Inf values.
 
     Inputs:
         - **x** (Tensor) - Input Tensor of any dimension. The data type is float16, float32 or float64.
 
     Outputs:
-        Tensor, has the same shape and data type as `x` if `x` has no nan or inf values.
+        Tensor, has the same shape and data type as `x` if `x` has no NaN or Inf values.
 
     Raises:
         TypeError: If `x` data type is not float16, float32, float64.
-        RuntimeError: If `x` has nan or inf values.
+        RuntimeError: If `x` has NaN or Inf values.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -297,7 +298,7 @@ class CheckNumerics(Primitive):
         self.init_prim_io_names(inputs=['x'], outputs=['y'])
 
 
-class Cast(PrimitiveWithInfer):
+class Cast(PrimitiveWithCheck):
     """
     Returns a tensor with the new specified data type.
 
@@ -330,7 +331,6 @@ class Cast(PrimitiveWithInfer):
 
     @prim_attr_register
     def __init__(self):
-        # if primitive need setattr in __infer__ need add this flag
         """Initialize Cast"""
         self.init_prim_io_names(inputs=['x', 'dst_type'], outputs=['output'])
 
@@ -348,35 +348,26 @@ class Cast(PrimitiveWithInfer):
                 return (True, Tensor(x, dtype=dtype))
         return (False, None)
 
-    def __infer__(self, x, t):
-        src_type = x['dtype']
-        dst_type = t['value']
-
-        validator.check_subclass("input_x", src_type, [mstype.tensor, mstype.number], self.name)
+    def infer_value(self, x, dst_type):
+        if x is None:
+            return None
+        src_type = mstype.get_py_obj_dtype(x)
+        validator.check_subclass("input_x", src_type,
+                                 [mstype.tensor, mstype.number], self.name)
         validator.check_subclass("type", dst_type, mstype.number, self.name)
 
         if isinstance(src_type, type(mstype.tensor)):
-            src_type = x['dtype'].element_type()
+            src_type = src_type.element_type()
         if isinstance(dst_type, type(mstype.tensor)):
             dst_type = dst_type.element_type()
-        self.add_prim_attr('DstT', dst_type)
-        self.add_prim_attr('SrcT', src_type)
-        self.add_prim_attr('dst_type', dst_type)
 
         value = None
-        if x['value'] is not None:
-            np_dst_type = mstype.dtype_to_nptype(dst_type)
-            if isinstance(x['value'], (int, float)):
-                value = Tensor(np.array(x['value']).astype(np_dst_type))
-            else:
-                value = Tensor(x['value'].asnumpy().astype(np_dst_type))
-
-        out = {'shape': x['shape'],
-               'dtype': mstype.tensor_type(t['value']),
-               'value': value}
-        if 'shape_value' in x:
-            out['shape_value'] = tuple(np.array(x['shape_value']).astype(np.int64))
-        return out
+        np_dst_type = mstype.dtype_to_nptype(dst_type)
+        if isinstance(x, (int, float)):
+            value = Tensor(np.array(x).astype(np_dst_type))
+        else:
+            value = Tensor(x.asnumpy().astype(np_dst_type))
+        return value
 
 
 class Im2Col(Primitive):
@@ -418,17 +409,8 @@ class Im2Col(Primitive):
             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.
-        padding_mode (str, optional): The optional value for pad mode, support "CALCULATED", "SAME" and "VALID".
-            Default: "CALCULATED".
-
-            - "SAME", the width and height of the output are the same as the value of the width and height of
-              the input divided by 'strides' rounded up.
-            - "VALID", return a valid calculated output without padding. Excess pixels that do not satisfy
-              the calculation are discarded.
-            - "CALCULATED", pads the input. Padding 'pads' size of zero on both sides of the input.
-
         pads (Union[int, tuple[int], list[int]], optional): The pad of the window, that must be a tuple of
-            one or two or four `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]`.
@@ -445,70 +427,58 @@ class Im2Col(Primitive):
         TypeError: If `ksizes` data type is not in Union[int, tuple[int], list[int]].
         TypeError: If `strides` data type is not in Union[int, tuple[int], list[int]].
         TypeError: If `dilations` data type is not in Union[int, tuple[int], list[int]].
-        TypeError: If `padding_mode` data type is not str.
         TypeError: If `pads` data type isnot in Union[int, tuple[int], list[int]].
-            when `padding_mode` is "CALCULATED".
         ValueError: If `ksizes` value is not greater than zero or elements number more than 2.
         ValueError: If `strides` value is not greater than zero or elements number more than 2.
         ValueError: If `dilations` value is not greater than zero or elements number more than 2.
-        ValueError: If `padding_mode` value is not in ["SAME", "VALID", "CALCULATED"].
         ValueError: If `pads` value is not greater than zero.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> x = Tensor(input_data=np.random.rand(4, 4, 32, 32), dtype=mstype.float16)
+        >>> 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)
         >>> print(y.shape)
-        (4, 36, 30, 30)
+        (4, 4, 9, 900)
     """
 
     @prim_attr_register
-    def __init__(self, ksizes, strides=1, dilations=1, padding_mode="CALCULATED", pads=0):
+    def __init__(self, ksizes, strides=1, dilations=1, pads=0):
         """Initialize Im2Col."""
         self.init_prim_io_names(inputs=['x'], outputs=['y'])
 
         validator.check_value_type('ksizes', ksizes, [int, tuple, list], self.name)
         validator.check_value_type('strides', strides, [int, tuple, list], self.name)
         validator.check_value_type('dilations', dilations, [int, tuple, list], self.name)
-        validator.check_value_type('padding_mode', padding_mode, [str], self.name)
         validator.check_value_type('pads', pads, [int, tuple, list], self.name)
 
-        self.padding_mode = validator.check_string(
-            padding_mode.upper(), ["SAME", "VALID", "CALCULATED"], 'padding_mode', self.name)
         self.ksizes = (ksizes, ksizes) if isinstance(ksizes, int) else ksizes
         self.strides = (strides, strides) if isinstance(strides, int) else strides
         self.dilations = (dilations, dilations) if isinstance(dilations, int) else dilations
-        if isinstance(pads, (list, tuple)):
-            if len(pads) == 2:
-                self.pads = (pads[0], pads[0], pads[1], pads[1])
-            else:
-                self.pads = pads
-        if isinstance(pads, int):
-            self.pads = (pads, pads, pads, pads)
+        self.pads = (pads, pads) if isinstance(pads, int) else pads
 
-        validator.check("ksizes size", len(self.ksizes), "", [1, 2], Rel.IN, self.name)
+        validator.check("ksizes size", len(self.ksizes), "", [1, 2], validator.IN, self.name)
         validator.check_positive_int_sequence(self.ksizes, "ksizes", self.name)
-        validator.check("strides size", len(self.strides), "", [1, 2], Rel.IN, self.name)
+        validator.check("strides size", len(self.strides), "", [1, 2], validator.IN, self.name)
         validator.check_positive_int_sequence(self.strides, "strides", self.name)
-        validator.check("dilations size", len(self.dilations), "", [1, 2], Rel.IN, self.name)
+        validator.check("dilations size", len(self.dilations), "", [1, 2], validator.IN, self.name)
         validator.check_positive_int_sequence(self.dilations, "dilations", self.name)
-        if self.padding_mode == "CALCULATED":
-            validator.check("pads size", len(self.pads), "", [1, 2, 4], Rel.IN, self.name)
-            validator.check_non_negative_int_sequence(self.pads, "pads", self.pads)
+        validator.check("pads size", len(self.pads), "", [1, 2], validator.IN, self.name)
+        validator.check_non_negative_int_sequence(self.pads, "pads", self.name)
 
         self.add_prim_attr('ksizes', self.ksizes)
         self.add_prim_attr('strides', self.strides)
         self.add_prim_attr('dilations', self.dilations)
         self.add_prim_attr('pads', self.pads)
-        self.add_prim_attr('padding_mode', self.padding_mode)
+        self.add_prim_attr('padding_mode', "CALCULATED")
 
 
 class Col2Im(Primitive):
     r"""
-    Combines an array of sliding local blocks into a large containing tensor.
+    Combines an array of sliding local blocks into a large containing tensor. It is
+    usually used to reconstruct an image from a set of image patches(or sliding local blocks).
 
     Consider a batched :attr:`input` tensor containing sliding local blocks,
     e.g., patches of images, of shape :math:`(N, C, \prod(\text{kernel_size}), L)`,
@@ -521,34 +491,22 @@ class Col2Im(Primitive):
 
     .. math::
         L = \prod_d \left\lfloor\frac{\text{output_size}[d] + 2 \times \text{padding}[d] %
-            - \text{dilation}[d] \times (\text{kernel_size}[d] - 1) - 1}{\text{stride}[d]} + 1\right\rfloor,
-
-    where :math:`d` is over all spatial dimensions.
+            - \text{dilation}[d] \times (\text{kernel_size}[d] - 1) - 1}{\text{stride}[d]} + 1\right\rfloor
 
-    :attr:`output_size` describes the spatial shape of the large containing
-    tensor of the sliding local blocks. It is useful to resolve the ambiguity
-    when multiple input shapes map to same number of sliding blocks, e.g.,
-    with ``stride > 0``.
-
-    The :attr:`padding`, :attr:`stride` and :attr:`dilation` arguments specify
-    how the sliding blocks are retrieved.
+    where :math:`d` is over all spatial dimensions. The `padding`, `stride`
+    and `dilation` arguments specify how the sliding blocks are retrieved.
 
-    :attr:`stride` controls the stride for the sliding blocks.
-
-    :attr:`padding` controls the amount of implicit zero-paddings on both
-    sides for :attr:`padding` number of points for each dimension before
-    reshaping.
-
-    :attr:`dilation` controls the spacing between the kernel points.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Args:
         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]]): The size of the dilation, should be two positive int
+        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.
-        padding (Union[int, tuple[int], list[int]]): The size of the padding, should be two int
+        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.
-        stride (Union[int, tuple[int], list[int]]): The size of the stride, should be two positive int
+        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.
 
     Inputs:
@@ -567,7 +525,7 @@ class Col2Im(Primitive):
         ValueError: If x.shape[3] does not match the calculated number of sliding blocks.
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -595,13 +553,13 @@ class Col2Im(Primitive):
         self.padding = (padding, padding) if isinstance(padding, int) else padding
         self.stride = (stride, stride) if isinstance(stride, int) else stride
 
-        validator.check("kernel_size size", len(self.kernel_size), "", 2, Rel.EQ, self.name)
+        validator.check("kernel_size size", len(self.kernel_size), "", 2, validator.EQ, self.name)
         validator.check_positive_int_sequence(self.kernel_size, "kernel_size", self.name)
-        validator.check("dilation size", len(self.dilation), "", 2, Rel.EQ, self.name)
+        validator.check("dilation size", len(self.dilation), "", 2, validator.EQ, self.name)
         validator.check_positive_int_sequence(self.dilation, "dilation", self.name)
-        validator.check("padding size", len(self.padding), "", 2, Rel.EQ, self.name)
+        validator.check("padding size", len(self.padding), "", 2, validator.EQ, self.name)
         validator.check_non_negative_int_sequence(self.padding, "padding", self.name)
-        validator.check("stride size", len(self.stride), "", 2, Rel.EQ, self.name)
+        validator.check("stride size", len(self.stride), "", 2, validator.EQ, self.name)
         validator.check_positive_int_sequence(self.stride, "stride", self.name)
 
         self.add_prim_attr('kernel_size', self.kernel_size)
@@ -637,9 +595,9 @@ class Reshape(PrimitiveWithCheck):
     def infer_value(self, x, shape):
         """infer value"""
         # for shape is not constant
-        if shape is None or x is None:
+        if shape is None or self.none_in_tuple_or_list(shape) or x is None:
             return None
-        if isinstance(shape, Tensor_):
+        if isinstance(shape, (Tensor, Tensor_)):
             validator.check_tensor_dtype_valid("shape", mstype.tensor_type(shape.dtype),
                                                [mstype.int32, mstype.int64], self.name)
             shape = shape.asnumpy().tolist()
@@ -676,10 +634,13 @@ class Reshape(PrimitiveWithCheck):
             out = Tensor(x.asnumpy().reshape(shape))
         return out
 
+    def none_in_tuple_or_list(self, x):
+        return isinstance(x, (tuple, list)) and None in x
+
 
 class Shape(Primitive):
     """
-    Returns the shape of the input tensor. And it used to be static shape.
+    Returns the shape of the input tensor.
 
     Refer to :func:`mindspore.ops.shape` for more details.
 
@@ -816,10 +777,8 @@ class ConjugateTranspose(Primitive):
     """
     Calculate the conjugate matrix of input x which has been transposed according to input perm.
 
-    The type and rank of the output y is the same as the input x. And the shape and value of the input x
-    and the output y satisfy:
-    y.shape[i] == x.shape[perm[i]] for i in [0, 1, ..., rank(x) - 1]
-    y[i,j,k,...,s,t,u] == conj(x[perm[i], perm[j], perm[k],...,perm[s], perm[t], perm[u]])
+    .. math::
+        y[i,j,k,...,s,t,u] == conj(x[perm[i], perm[j], perm[k],...,perm[s], perm[t], perm[u]])
 
     Inputs:
         - **x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
@@ -829,7 +788,12 @@ class ConjugateTranspose(Primitive):
 
     Outputs:
         Tensor, the type of output tensor is the same as `x` and the shape of output tensor is decided by the
-        shape of `x` and the value of `Conj(perm)`.
+        shape of `x` and the value of `Conj(perm)`:
+
+        .. math::
+            y.shape[i] = x.shape[perm[i]]
+
+        where i is in range [0, rank(x) - 1].
 
     Raises:
         TypeError: If `perm` is not a tuple.
@@ -837,7 +801,7 @@ class ConjugateTranspose(Primitive):
         ValueError: If the same element exists in `perm`.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([[1 + 1j,2 + 2j], [3 + 3j, 4 + 4j]]), mindspore.complex64)
@@ -920,18 +884,17 @@ class UniqueConsecutive(Primitive):
     """
     Returns the elements that are unique in each consecutive group of equivalent elements in the input tensor.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Refer to :func:`mindspore.ops.unique_consecutive` for more details.
 
     Supported Platforms:
-        ``Ascend`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> from mindspore import dtype as mstype
-        >>> from mindspore.ops import UniqueConsecutive
         >>> x = Tensor(np.array([1, 1, 2, 2, 3, 1, 1, 2]), mstype.int32)
-        >>> unique_consecutive = UniqueConsecutive(True, True, None)
+        >>> unique_consecutive = ops.UniqueConsecutive(True, True, None)
         >>> output, idx, counts = unique_consecutive(x)
         >>> print(output)
         [1 2 3 1 2]
@@ -943,6 +906,7 @@ class UniqueConsecutive(Primitive):
 
     @prim_attr_register
     def __init__(self, return_idx=False, return_counts=False, axis=None):
+        """Initialize UniqueConsecutive"""
         self.init_prim_io_names(inputs=['x'], outputs=['output'])
         validator.check_value_type("return_idx", return_idx, [bool], self.name)
         validator.check_value_type("return_counts", return_counts, [bool], self.name)
@@ -991,20 +955,22 @@ class Gather(Primitive):
         >>> print(output)
         [[1.  2.  3.  4.]
          [9. 10. 11. 12.]]
-        >>> # case4: input_indices is a Tensor with shape (2, ). input_params is a Tensor with shape (3, 4) and axis is 1.
+        >>> # case4: input_indices is a Tensor with shape (2, ).
+        >>> # input_params is a Tensor with shape (3, 4) and axis is 1, batch_dims is 1.
         >>> input_params = Tensor(np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]), mindspore.float32)
-        >>> input_indices = Tensor(np.array([0, 2]), mindspore.int32)
+        >>> input_indices = Tensor(np.array([0, 2, 1]), mindspore.int32)
         >>> axis = 1
-        >>> output = ops.Gather()(input_params, input_indices, axis)
+        >>> batch_dims = 1
+        >>> output = ops.Gather(batch_dims)(input_params, input_indices, axis)
         >>> print(output)
-        [[1.  3.]
-         [5.  7.]
-         [9. 11.]]
+        [ 1.  7. 10.]
     """
 
     @prim_attr_register
-    def __init__(self):
+    def __init__(self, batch_dims=0):
         """Initialize Gather"""
+        validator.check_value_type("batch_dims", batch_dims, [int], self.name)
+        self.add_prim_attr("batch_dims", batch_dims)
         self.init_prim_io_names(inputs=['params', 'indices', 'axis'], outputs=['output'])
 
 
@@ -1018,6 +984,7 @@ class GatherV2(PrimitiveWithCheck):
     @prim_attr_register
     def __init__(self):
         """Initialize GatherV2"""
+        self.add_prim_attr("batch_dims", 0)
         self.init_prim_io_names(inputs=['params', 'indices', 'axis'], outputs=['output'])
 
     def __check__(self, params, indices, axis):
@@ -1027,7 +994,7 @@ class GatherV2(PrimitiveWithCheck):
         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, Rel.INC_LEFT, "axis", self.name)
+        validator.check_int_range(axis_v, -rank, rank, validator.INC_LEFT, "axis", self.name)
 
 
 class SparseGatherV2(PrimitiveWithCheck):
@@ -1074,7 +1041,7 @@ class SparseGatherV2(PrimitiveWithCheck):
         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, Rel.INC_LEFT, "axis", self.name)
+        validator.check_int_range(axis_v, -rank, rank, validator.INC_LEFT, "axis", self.name)
 
 
 class Padding(Primitive):
@@ -1139,6 +1106,17 @@ 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.
+
+    Inputs:
+        - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+
+    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`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -1180,7 +1158,7 @@ class Split(Primitive):
         self.add_prim_attr('num_split', self.output_num)
 
 
-class Rank(PrimitiveWithInfer):
+class Rank(Primitive):
     """
     Returns the rank of a tensor.
 
@@ -1203,20 +1181,13 @@ class Rank(PrimitiveWithInfer):
     def __init__(self):
         """Initialize Rank"""
 
-    def __infer__(self, x):
-        validator.check_subclass("x", x['dtype'], mstype.tensor, self.name)
-        out = {'shape': None,
-               'dtype': None,
-               'value': len(x['shape'])}
-        return out
-
     def __call__(self, x):
         if not isinstance(x, (Tensor, Tensor_)):
             raise TypeError("the input x must be Tensor!")
         return len(x.shape)
 
 
-class Size(PrimitiveWithInfer):
+class Size(Primitive):
     r"""
     Returns a Scalar of type int that represents the size of the input Tensor and the total number of elements in the
     Tensor.
@@ -1238,23 +1209,13 @@ class Size(PrimitiveWithInfer):
     def __init__(self):
         """Initialize Size"""
 
-    def __infer__(self, x):
-        size = 1
-        validator.check_subclass("x", x['dtype'], mstype.tensor, self.name)
-        shp = x['shape']
-        if not shp:
-            size = 0
-        else:
-            size = functools.reduce(lambda x, y: x * y, x['shape'])
-        out = {'shape': None,
-               'dtype': mstype.int64,
-               'value': size}
-        return out
-
 
 class MatrixDiagV3(Primitive):
     """
-    Returns a batched diagonal tensor with given batched diagonal values.
+    Constructs a diagonal matrix or a batch of diagonal matrices from a given input Tensor.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Refer to :func:`mindspore.ops.matrix_diag` for more details.
 
@@ -1291,6 +1252,9 @@ class MatrixDiagPartV3(Primitive):
     r"""
     Returns the diagonal part of a tensor.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Refer to :func:`mindspore.ops.matrix_diag_part` for more details.
 
     Supported Platforms:
@@ -1323,47 +1287,62 @@ class MatrixDiagPartV3(Primitive):
 
 class MatrixSetDiagV3(Primitive):
     r"""
-    Returns a batched matrix tensor with new batched diagonal values.
-    Given x and diagonal, this operation returns a tensor with the same shape and values as x, except for the specified
-    diagonals of the innermost matrices. These will be overwritten by the values in diagonal. Some diagonals are shorter
-    than `max_diag_len` and need to be padded, where `max_diag_len` is the longest diagonal value.
-    The diagonal.shape[-2] must be equal to num_diags calculated by :math:`k[1] - k[0] + 1` .
-    The diagonal.shape[-1] must be
-    equal to the longest diagonal value `max_diag_len` calculated
-    by :math:`min(x.shape[-2] + min(k[1], 0), x.shape[-1] + min(-k[0], 0))` .
-    Let x have r + 1 dimensions [I, J, ..., L, M, N].
-    The diagonal tensor has rank r with shape :math:`[I, J, ..., L, max\_diag\_len]`
-    when k is an integer or :math:`k[0] == k[1]` . Otherwise, it has rank r + 1
-    with shape :math:`[I, J, ..., L, num\_diags, max\_diag\_len]` .
+    Updates the diagonal part of a batched tensor.
+    It takes an Tensor `x` and `diagonal` as input and returns a Tensor in which
+    the specified diagonal values in the innermost matrices will be replaced
+    by the values in the `diagonal`.
+
+    Diagonals shorter than `max_diag_len` need to be padded, where `max_diag_len` is the
+    longest diagonal value.
+    The dimension of `diagonal` is :math:`shape[-2]` must be equal to num_diags calculated by
+    :math:`num\_diags = k[1] - k[0] + 1`.
+    The dimension of `diagonal` is :math:`shape[-1]` must be equal to the longest diagonal value `max_diag_len`
+    calculated by :math:`max\_diag\_len = min(x.shape[-2] + min(k[1], 0), x.shape[-1] + min(-k[0], 0))`.
+
+    Assume `x` is an n-D Tensor with shape :math:`(d_1, d_2, ..., d_{n-2}, d_{n-1}, d_n)`.
+    If `k` is an integer or :math:`k[0] == k[1]`, `diagonal` is an (n-1)-D Tensor with
+    shape :math:`(d_1, d_2, ..., d_{n-2}, max\_diag\_len)`
+    Otherwise, it has the same rank as `x`
+    with shape :math:`(d_1, d_2, ..., d_{n-2}, num\_diags, max\_diag\_len)`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Args:
-        align (str, optional): An optional string from: "RIGHT_LEFT", "LEFT_RIGHT", "LEFT_LEFT", "RIGHT_RIGHT".
-            Align is a string specifying how superdiagonals and subdiagonals should be aligned, respectively.
+        align (str, optional): specifies how superdiagonals and subdiagonals should be aligned.
+            Supported values:"RIGHT_LEFT", "LEFT_RIGHT", "LEFT_LEFT", "RIGHT_RIGHT".
             Default: "RIGHT_LEFT".
 
-            - "RIGHT_LEFT" aligns superdiagonals to the right (left-pads the row) and subdiagonals to the left
-              (right-pads the row).
-            - "LEFT_RIGHT" aligns superdiagonals to the left (right-pads the row) and subdiagonals to the right
-              (left-pads the row).
-            - "LEFT_LEFT" aligns superdiagonals to the left (right-pads the row) and subdiagonals to the left
-              (right-pads the row).
-            - "RIGHT_RIGHT" aligns superdiagonals to the right (left-pads the row) and subdiagonals to the right
-              (left-pads the row).
+            - 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 + 1, where r >= 1.
-        - **diagonal** (Tensor) - A Tensor. Have the same dtype as x. Rank r when k is an integer or k[0] == k[1].
-          Otherwise, it has rank r + 1.
-        - **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]).
-          Input k must be const Tensor when taking Graph mode.
+        - **x** (Tensor) - A n-D Tensor, where :math:`n >= 2`.
+        - **diagonal** (Tensor) - A Tensor with the same dtype as `x`. Its rank depends on `k`.
+          If `k` is an integer or :math:`k[0] == k[1]`, its dimension is :math:`n-1`.
+          Otherwise, it has dimension :math:`n`.
+        - **k** (Tensor) - Diagonal offset(s), Tensor of type int32.
+          `k` can either be a single integer, which represents a single diagonal,
+          or a pair of integers that specify the low and high ends of a matrix band.
+          In this case, `k[0]` should not be greater than `k[1]`.
+          The value of `k` has restructions, which means that value of `k` must be in range
+          :math:`(-x.shape[-2], x.shape[-1])`.
+          Input `k` must be const Tensor when taking Graph mode.
+
+          - `k > 0` refers to a superdiagonal.
+          - `k = 0` refers to the main diagonal.
+          - `k < 0` refers to subdiagonals.
 
     Outputs:
-        Tensor. The same type as x.
-        Let x has r+1 dimensions :math:`[I, J, ..., L, M, N]` .
-        The output is a tensor of rank r+1 with dimensions :math:`[I, J, ..., L, M, N]` , the same as input x.
+        Tensor. The same type and shape as `x`.
 
     Raises:
         TypeError: If any input is not Tensor.
@@ -1376,13 +1355,13 @@ 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.shape[-2] is not equal to num_diags calculated by :math:`k[1] - k[0] + 1` .
-        ValueError: If the value of `k` is not in (-x.shape[-2], x.shape[-1]).
-        ValueError: If the diagonal.shape[-1] is not equal to the max_diag_len calculated by
+        ValueError: If the diagonal :math:`shape[-2]` is not equal to num_diags calculated by :math:`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))` .
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([[7, 7, 7, 7],
@@ -1402,6 +1381,11 @@ class MatrixSetDiagV3(Primitive):
         >>> print(output.shape)
         (3, 4)
     """
+    __mindspore_signature__ = (
+        sig.make_sig('x', dtype=sig.sig_dtype.T1),
+        sig.make_sig('diagonal', dtype=sig.sig_dtype.T1),
+        sig.make_sig('k', dtype=sig.sig_dtype.T2)
+    )
 
     @prim_attr_register
     def __init__(self, align="RIGHT_LEFT"):
@@ -1414,12 +1398,13 @@ class MatrixSetDiagV3(Primitive):
 
 class MatrixBandPart(Primitive):
     r"""
-    Copy a tensor setting everything outside a central band in each innermost matrix to zero.
+    Extracts the central diagonal band of each matrix in a tensor, with all values outside
+    the central band set to zero.
 
     Refer to :func:`mindspore.ops.matrix_band_part` for more details.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+
 
     Examples:
         >>> matrix_band_part = ops.MatrixBandPart()
@@ -1444,24 +1429,10 @@ class MatrixBandPart(Primitive):
 
 class Fill(PrimitiveWithCheck):
     """
-    Create a Tensor of the specified shape and fill it with the specified value.
-
-    Refer to :func:`mindspore.ops.fill` for more details.
+    The Fill interface is deprecated, please use the :class:`mindspore.ops.FillV2` instead.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> fill = ops.Fill()
-        >>> output = fill(mindspore.float32, (2, 2), 1)
-        >>> print(output)
-        [[1. 1.]
-         [1. 1.]]
-        >>> output = fill(mindspore.float32, (3, 3), 0)
-        >>> print(output)
-        [[0. 0. 0.]
-         [0. 0. 0.]
-         [0. 0. 0.]]
+        Deprecated
     """
 
     @prim_attr_register
@@ -1469,9 +1440,26 @@ class Fill(PrimitiveWithCheck):
         """Initialize Fill"""
         self.init_prim_io_names(inputs=['type', 'shape', 'value'], outputs=['y'])
 
+    def __call__(self, dtype, dims, x):
+        if dtype not in mstype.all_types and dtype not in [mstype.uint16, mstype.uint32, mstype.uint64]:
+            raise TypeError(
+                f"For \'{self.name}\', the supported data type is ['bool', 'int8', 'int16', 'int32', 'int64', 'uint8', "
+                "'uint16', 'uint32', 'uint64','float16', 'float32', 'float64'], but got an invalid dtype!.")
+        x_nptype = mstype.dtype_to_nptype(dtype)
+        if not isinstance(dims, Tensor) and not isinstance(dims, tuple):
+            raise TypeError(f"For \'{self.name}\', input[1] must be tensor.")
+        if not isinstance(x, Tensor) and not isinstance(x, float) and not isinstance(x, int):
+            raise TypeError(f"For \'{self.name}\', the value input only takes scalar or scalar within a tensor!.")
+        if isinstance(dims, Tensor):
+            dims = dims.asnumpy()
+        if isinstance(x, Tensor):
+            x = x.asnumpy()
+        ret = np.full(dims, x, x_nptype)
+        return Tensor(ret)
+
     def infer_value(self, dtype, dims, x):
         x_nptype = mstype.dtype_to_nptype(dtype)
-        if dims is not None and not is_shape_unknown(dims) and x is not None:
+        if dims is not None and None not in dims and x is not None:
             if isinstance(dims, Tensor):
                 dims = dims.asnumpy()
             if isinstance(x, Tensor):
@@ -1483,12 +1471,11 @@ class Fill(PrimitiveWithCheck):
 
 class Fills(Primitive):
     """
-    Create a tensor of the same shape and type as the input tensor and fill it with specified value.
-
-    Refer to :func:`mindspore.ops.fills` for more details.
+    The `Fills` primitive  is deprecated.
+    Please use :func:`mindspore.ops.fill` instead.
 
     Supported Platforms:
-        ``GPU``
+        Deprecated
 
     Examples:
         >>> import numpy as np
@@ -1507,15 +1494,68 @@ class Fills(Primitive):
         self.init_prim_io_names(inputs=['x', 'value'], outputs=['y'])
 
 
+class FillV2(PrimitiveWithCheck):
+    """
+    Creates a tensor with shape described by `shape` and fills it with values in `value` .
+
+    Inputs:
+        - **shape** (Union[Tuple[int], Tensor[int]]) - 1-D Tensor or Tuple, specify the shape
+          of output tensor. Its dtype must be int32 or int64.
+        - **value** (Tensor) - A 0-D Tensor, the value to fill the output tensor `y` .
+
+    Outputs:
+        - **y** (Tensor) - A tensor, its shape and value are described above.
+
+    Raises:
+        TypeError: If `shape` is not a 1-D tensor or tuple.
+        TypeError: If the data type of `shape` is not int32 or int64.
+        ValueError: If `value` is not a 0-D Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> fillV2 = ops.FillV2()
+        >>> output = fillV2(Tensor([2, 3], mindspore.int32), Tensor(1, mindspore.float32))
+        >>> print(output)
+        [[1. 1. 1.]
+         [1. 1. 1.]]
+        >>> output = fillV2(Tensor([3, 3], mindspore.int64), Tensor(0, mindspore.int32))
+        >>> print(output)
+        [[0 0 0]
+         [0 0 0]
+         [0 0 0]]
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize FillV2"""
+        self.init_prim_io_names(inputs=['shape', 'value'], outputs=['y'])
+
+    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
+
+
 class Ones(Primitive):
     r"""
     Creates a tensor filled with value ones.
 
-    Creates a tensor with shape described by the first argument and
-    fills it with value ones in type of the second argument.
-
     Refer to :func:`mindspore.ops.ones` for more details.
 
+    Inputs:
+        - **shape** (Union[tuple[int], int]) - The specified shape of output tensor.
+        - **type** (:class:`mindspore.dtype`) - The specified type of output tensor.
+
+    Outputs:
+        Tensor, has the same type and shape as input shape value.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -1539,6 +1579,8 @@ class Ones(Primitive):
 
 class Zeros(Primitive):
     r"""
+    Zeros will be deprecated in the future. Please use class `mindspore.ops.zeros` instead.
+
     Creates a tensor filled with value zeros.
 
     Creates a tensor with shape described by the first argument and
@@ -1546,8 +1588,7 @@ class Zeros(Primitive):
 
     Inputs:
         - **shape** (Union[tuple[int], int]) - The specified shape of output tensor.
-          Only constant positive int is allowed.
-        - **type** (mindspore.dtype) - The specified type of output tensor. Only constant value is allowed.
+        - **type** (mindspore.dtype) - The specified type of output tensor.
 
     Outputs:
         Tensor, has the same type and shape as input shape value.
@@ -1557,7 +1598,7 @@ class Zeros(Primitive):
         TypeError: If `shape` is a tuple whose elements are not all int.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        Deprecated
 
     Examples:
         >>> zeros = ops.Zeros()
@@ -1654,7 +1695,7 @@ class TupleToArray(PrimitiveWithInfer):
 
     def infer_value(self, x):
         validator.check_value_type("x", x, [tuple], self.name)
-        validator.check("size of x", len(x), '', 0, Rel.GT, self.name)
+        validator.check("size of x", len(x), '', 0, validator.GT, self.name)
         dtype = type(x[0])
         for i, item in enumerate(x):
             validator.check_value_type(f"x[{i}]", item, [numbers.Number], self.name)
@@ -1675,6 +1716,24 @@ 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.
@@ -1694,10 +1753,10 @@ class ScalarToTensor(PrimitiveWithInfer):
 
     @prim_attr_register
     def __init__(self):
-        pass
+        self.init_prim_io_names(inputs=['input_scalar', 'dtype'], outputs=['output_data'])
 
-    def infer_value(self, x, dtype=mstype.float32):
-        validator.check_value_type("x", x, [int, float], self.name)
+    def __call__(self, x, dtype=mstype.float32):
+        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))
@@ -1768,13 +1827,13 @@ class InvertPermutation(PrimitiveWithInfer):
             if z[i - 1] == z[i]:
                 raise ValueError(f"For '{self.name}', the 'input_x' can not contain duplicate values, "
                                  f"but got duplicated {z[i]} in the 'input_x'.")
-        validator.check(f'value min', min(x_value), '', 0, Rel.EQ, self.name)
-        validator.check(f'value max', max(x_value), '', len(x_value) - 1, Rel.EQ, self.name)
+        validator.check(f'value min', min(x_value), '', 0, validator.EQ, self.name)
+        validator.check(f'value max', max(x_value), '', len(x_value) - 1, validator.EQ, self.name)
 
         y = [None] * len(x_value)
         for i, value in enumerate(x_value):
             validator.check_value_type("input[%d]" % i, value, [int], self.name)
-            validator.check(f'value', z[i], f'index', i, Rel.EQ, self.name)
+            validator.check(f'value', z[i], f'index', i, validator.EQ, self.name)
             y[value] = i
             z.append(value)
         return {'shape': x_shp,
@@ -1788,6 +1847,22 @@ class Argmax(Primitive):
 
     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`.
+
+    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.
+
+    Outputs:
+        Tensor, indices of the max value of input tensor across the axis.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -1822,7 +1897,7 @@ class Argmin(Primitive):
 
     Inputs:
         - **input_x** (Tensor) - Input tensor.
-          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.
 
           - Ascend: Float16, Float32, Float64, Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64.
 
@@ -1914,7 +1989,7 @@ class ArgminV2(Primitive):
 
 class ArgMaxWithValue(Primitive):
     """
-    Calculates the maximum value along with the given axis for the input tensor and, returns the maximum values and
+    Calculates the maximum value along with the given axis for the input tensor, and returns the maximum values and
     indices.
 
     Note:
@@ -2121,11 +2196,15 @@ class Tile(PrimitiveWithInfer):
 
     def __infer__(self, x, multiples):
         multiples_v = multiples['value']
-        if multiples_v is None:
+        if multiples_v is None or None in multiples_v:
             if 'max_value' not in multiples or 'min_value' not in multiples:
-                if len(multiples['shape']) != 1:
+                if multiples_v is not None:
+                    shape = [len(multiples['shape'])]
+                else:
+                    shape = multiples['shape']
+                if len(shape) != 1:
                     raise ValueError(f'For \'{self.name}\', the dim of multiples must be 1.')
-                rank = max(len(x['shape']), multiples['shape'][0])
+                rank = max(len(x['shape']), shape[0])
                 out_shape = [-1] * rank
                 return {
                     'shape': out_shape,
@@ -2218,20 +2297,22 @@ class UnsortedSegmentMin(PrimitiveWithCheck):
     def __check__(self, x, segment_ids, num_segments):
         x_shape = x['shape']
         segment_ids_shape = segment_ids['shape']
-        valid_type = [mstype.float16, mstype.float32, mstype.int32]
+        valid_type = [mstype.float16, mstype.float32, mstype.int32, mstype.int8, mstype.uint8,
+                      mstype.int16, mstype.uint16, mstype.uint32, mstype.int64, mstype.uint64, mstype.float64]
         validator.check_tensor_dtype_valid("x", x['dtype'], valid_type, self.name)
-        validator.check_tensor_dtype_valid("segment_ids", segment_ids['dtype'], [mstype.int32], self.name)
+        validator.check_tensor_dtype_valid("segment_ids", segment_ids['dtype'], [mstype.int32, mstype.int64], self.name)
 
         # support vmap : segment_ids_shape support batch rank
         if not hasattr(self, 'batch_rank'):
-            validator.check_equal_int(len(segment_ids_shape), 1, "rank of segment_ids_shape", self.name)
+            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)
 
         num_segments_type = num_segments['dtype']
         validator.check_subclass("num_segments", num_segments_type, [mstype.number], self.name)
         if not is_shape_unknown(x_shape) and not is_shape_unknown(segment_ids_shape):
             # only validate when both shapes fully known
             validator.check(f'first shape of input_x', x_shape[0],
-                            'length of segments_id', segment_ids_shape[0], Rel.EQ, self.name)
+                            '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)
@@ -2325,21 +2406,23 @@ class UnsortedSegmentMax(PrimitiveWithCheck):
     def __check__(self, x, segment_ids, num_segments):
         x_shape = x['shape']
         segment_ids_shape = segment_ids['shape']
-        valid_type = [mstype.float16, mstype.float32, mstype.int32]
+        valid_type = [mstype.float16, mstype.float32, mstype.int32, mstype.int8, mstype.uint8,
+                      mstype.int16, mstype.uint16, mstype.uint32, mstype.int64, mstype.uint64, mstype.float64]
         validator.check_tensor_dtype_valid("x", x['dtype'], valid_type, self.name)
         validator.check_tensors_dtypes_same_and_valid({"segment_ids": segment_ids['dtype']},
                                                       [mstype.int32, mstype.int64], self.name)
 
         # support vmap : segment_ids_shape support batch rank
         if not hasattr(self, 'batch_rank'):
-            validator.check_equal_int(len(segment_ids_shape), 1, "rank of segment_ids_shape", self.name)
+            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)
 
         num_segments_type = num_segments['dtype']
         validator.check_subclass("num_segments", num_segments_type, [mstype.number], self.name)
         if not is_shape_unknown(x_shape) and not is_shape_unknown(segment_ids_shape):
             # only validate when both shapes fully known
             validator.check(f'first shape of input_x', x_shape[0],
-                            'length of segments_id', segment_ids_shape[0], Rel.EQ, self.name)
+                            '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)
@@ -2520,12 +2603,12 @@ class ParallelConcat(Primitive):
 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, Rel.GE, "len of input_x", 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)
 
     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], Rel.EQ, prim_name, TypeError)
+        validator.check('x_type[%d]' % i, x_type[i], 'base', x_type[0], validator.EQ, prim_name, TypeError)
 
     new_x_shape = []
     for i, shp in enumerate(x_shape):
@@ -2543,14 +2626,14 @@ def _get_stack_shape(value, x_shape, x_type, axis, prim_name):
     rank_base = len(new_x_shape[0]["shape"])
     for i in range(1, n):
         validator.check('len of x_shape[%d]' % new_x_shape[i]["id"], len(new_x_shape[i]["shape"]),
-                        'len of x_shape[0]', rank_base, Rel.EQ, prim_name, ValueError)
+                        'len of x_shape[0]', rank_base, validator.EQ, prim_name, ValueError)
         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']))
 
-    validator.check_int_range(axis, -rank_base - 1, rank_base, Rel.INC_BOTH, 'axis', prim_name)
+    validator.check_int_range(axis, -rank_base - 1, rank_base, validator.INC_BOTH, 'axis', prim_name)
     if axis < 0:
         axis = axis + rank_base + 1
 
@@ -2669,7 +2752,7 @@ class Unpack(PrimitiveWithInfer):
         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, Rel.INC_LEFT, 'axis value', self.name)
+        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]
@@ -2677,7 +2760,7 @@ class Unpack(PrimitiveWithInfer):
         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, Rel.EQ,
+        validator.check_int(output_valid_check, 0, validator.EQ,
                             "The dimension which to unstack divides output_num", self.name)
         out_shapes = []
         out_dtypes = []
@@ -2786,7 +2869,7 @@ class Coalesce(Primitive):
 
     Inputs:
         - **x_indices** (Tensor) - A 2-D Tensor, represents the indices of the nonzero elements of the sparse tensor.
-          Supported data type is int64. It's elements should be non-negative. The shape is :math:`(y, x)`.
+          Supported data type is int64. Its elements should be non-negative. The shape is :math:`(y, x)`.
         - **x_values** (Tensor) - A 1-D Tensor, represents the values corresponding to the indices in `x_indices`.
           Supported data types are float16 and float32. The shape is :math:`(x,)`.
         - **x_shape** (Tensor) - A 1-D Tensor, specifies the shape of the sparse tensor.
@@ -2848,7 +2931,7 @@ class ReverseV2(Primitive):
 
     Inputs:
         - **input_x** (Tensor) - The target tensor. The data type is Number except float64.
-          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.
 
     Outputs:
         Tensor, has the same shape and type as `input_x`.
@@ -2856,6 +2939,7 @@ class ReverseV2(Primitive):
     Raises:
         TypeError: If `axis` is neither list nor tuple.
         TypeError: If element of `axis` is not an int.
+        ValueError: There are multiple identical axes in `axis`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2925,7 +3009,7 @@ class Rint(Primitive):
 class Select(Primitive):
     r"""
     The conditional tensor determines whether the corresponding element in the output must be
-    selected from :math:`x` (if True) or :math:`y` (if False) based on the value of each
+    selected from `x` (if True) or `y` (if False) based on the value of each
     element.
 
     It can be defined as:
@@ -3126,25 +3210,32 @@ class StridedSlice(PrimitiveWithInfer):
         if len(tuple(filter(lambda x: x == '1', bin(ellipsis_mask)[-1:1:-1]))) > 1:
             raise ValueError(f"For '{self.name}', only support one ellipsis in the index, but got {ellipsis_mask}.")
         validator.check_non_negative_int(new_axis_mask, 'new_axis_mask', self.name)
-        validator.check_non_negative_int(shrink_axis_mask, 'shrink_axis_mask', self.name)
+        validator.check_non_negative_int(shrink_axis_mask, 'shrink_axis_mask',
+                                         self.name)
 
     def __infer__(self, x, begin, end, strides):
         begin_v, begin_len = self._check_and_get_value(begin, 'begin')
         end_v, end_len = self._check_and_get_value(end, 'end')
         strides_v, strides_len = self._check_and_get_value(strides, 'strides')
 
-        if None in (begin_v['value'], end_v['value'], strides_v['value']) or is_shape_unknown(x['shape']):
+        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'])
+
+        if not is_dynamic and (begin_len != strides_len or end_len != strides_len):
+            raise ValueError(
+                f"For '{self.name}', 'begin', 'end' and 'strides' must be the same length, but got "
+                f"'begin' length: {begin_len}, 'end' length: {end_len}, 'strides' length: {strides_len}."
+            )
+
+        if is_dynamic or is_dynamic_tuple or is_shape_unknown(x['shape']):
             ret_shape = self._compute_dynamic_slicing_shape(x, begin_v, end_v, strides_v, begin_len)
             rets = {'shape': ret_shape,
                     'dtype': x['dtype'],
                     'value': None}
-
             return rets
 
-        if begin_len != strides_len or end_len != strides_len:
-            raise ValueError(f"For '{self.name}', 'begin', 'end' and 'strides' must be the same length, but got "
-                             f"'begin' length: {begin_len}, 'end' length: {end_len}, 'strides' length: {strides_len}.")
-
         ret_shape = self._compute_slicing_shape(x['shape'], begin_v['value'], end_v['value'], strides_v['value'])
         if all(ret_shape):
             value = None
@@ -3183,7 +3274,7 @@ class StridedSlice(PrimitiveWithInfer):
                 # When slicing forward, if begin >= end, the length of the slicing is 0.
                 slicing_length = 0
             else:
-                slicing_length = 1 + (end - 1 - begin) // stride
+                slicing_length = -1
             return slicing_length
         # When slicing forward, convert begin and end to positive numbers.
         if begin >= x_dim or end < -x_dim:
@@ -3214,7 +3305,7 @@ class StridedSlice(PrimitiveWithInfer):
             if begin <= end:
                 slicing_length = 0
             else:
-                slicing_length = 1 + (end + 1 - begin) // stride
+                slicing_length = -1
             return slicing_length
         # When slicing backward, convert begin and end to negative numbers.
         if begin < -x_dim or end >= x_dim:
@@ -3250,6 +3341,10 @@ class StridedSlice(PrimitiveWithInfer):
             strides_value = strides_v['shape_value']
         return begin_value, end_value, strides_value
 
+    @staticmethod
+    def _is_none_in_tuple(x):
+        return isinstance(x, tuple) and None in x
+
     def _compute_slicing_length(self, begin, end, stride, x_dim):
         """Computes the length of the slicing."""
         if stride > 0:
@@ -3357,7 +3452,7 @@ class StridedSlice(PrimitiveWithInfer):
     def _compute_dynamic_slicing_length(self, begin, end, stride, x_dim):
         """Computes the length of the slicing for dynamic shape."""
         slicing_length = -1
-        if -1 in (begin, end, stride):
+        if None in (begin, end, stride) or -1 in (begin, end, stride):
             return slicing_length
         slicing_length = self._compute_slicing_length(begin, end, stride, x_dim)
         return slicing_length
@@ -3375,8 +3470,12 @@ class StridedSlice(PrimitiveWithInfer):
         ret_shape = []
         i, j = 0, 0
         slice_has_special_value = False
-        begin_value, end_value, strides_value = self._get_slice_value(begin_v, end_v, strides_v)
-        if None in (begin_v['value'], end_v['value'], strides_v['value']):
+        begin_value, end_value, strides_value = self._get_slice_value(
+            begin_v, end_v, strides_v)
+        is_dynamic_tuple = (self._is_none_in_tuple(begin_value)
+                            or self._is_none_in_tuple(end_value)
+                            or self._is_none_in_tuple(strides_value))
+        if None in (begin_v['value'], end_v['value'], strides_v['value']) or is_dynamic_tuple:
             slice_has_special_value = True
         while i < x_rank or j < slice_len:
             slicing_length = -1
@@ -3436,14 +3535,14 @@ class StridedSlice(PrimitiveWithInfer):
             }
             return slices, slice_shape[0]
 
-        if isinstance(slice_value, Tensor_):
+        if isinstance(slice_value, (Tensor, Tensor_)):
             validator.check_tensor_dtype_valid(name, slice_input['dtype'], [mstype.int64], self.name)
             slice_value = slice_value.asnumpy().tolist()
         elif not isinstance(slice_value, tuple):
             raise TypeError(f"For '{self.name}', both the 'begin', 'end', and 'strides' must be a tuple or Tensor, "
                             f"but got '{name}': {slice_value}.")
 
-        if tuple(filter(lambda x: not isinstance(x, int), slice_value)):
+        if tuple(filter(lambda x: x is not None and not isinstance(x, int), slice_value)):
             raise TypeError(f"For '{self.name}', the elements of 'begin', 'end', and 'strides' must be int, "
                             f"but got {name}: {slice_value}.")
 
@@ -3465,6 +3564,9 @@ class Diag(PrimitiveWithCheck):
 
     Constructs a diagonal tensor with a given diagonal values.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Refer to :func:`mindspore.ops.diag` for more details.
 
     Supported Platforms:
@@ -3498,11 +3600,11 @@ class Diag(PrimitiveWithCheck):
 class DiagPart(PrimitiveWithCheck):
     r"""
 
-    Extracts the diagonal part from given tensor.
+    Extracts the diagonal elements from the given Tensor.
 
-    Assume input has dimensions :math:`[D_1,..., D_k, D_1,..., D_k]`, the output is a tensor
-    of rank k with dimensions :math:`[D_1,..., D_k]` where:
-    :math:`output[i_1,..., i_k] = input[i_1,..., i_k, i_1,..., i_k]`.
+    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]`.
 
     Inputs:
         - **input_x** (Tensor) - The rank of input tensor is 2k(k > 0).
@@ -3545,12 +3647,15 @@ class DiagPart(PrimitiveWithCheck):
 
 class Mvlgamma(Primitive):
     r"""
-    Computes the multivariate log-gamma function with dimension `p` element-wise.
+    Calculates the multivariate log-gamma function element-wise for a given dimension `p`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Refer to :func:`mindspore.ops.mvlgamma` for more details.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([[3, 4, 5], [4, 2, 6]]), mindspore.float32)
@@ -3575,6 +3680,17 @@ class Eye(Primitive):
 
     Refer to :func:`mindspore.ops.eye` for more details.
 
+    Inputs:
+        - **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.
+
+    Outputs:
+        Tensor, a tensor with ones on the diagonal and the rest of elements are zero. The shape of `output` depends on
+        the user's Inputs `n` and `m`. And the data type depends on Inputs `t`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -3769,7 +3885,7 @@ class ResizeNearestNeighborV2(Primitive):
         ValueError: If attr `half_pixel_centers` and `align_corners` are True at the same time.
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> input_tensor = Tensor(np.ones((1, 4, 4, 1)), mstype.float32)
@@ -3830,7 +3946,6 @@ class ScatterUpdate(Primitive):
     for each `i, ..., j` in `indices.shape`:
 
     .. math::
-
         \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.
@@ -3842,7 +3957,7 @@ class ScatterUpdate(Primitive):
 
     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 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,
@@ -3911,7 +4026,7 @@ class ScatterNdUpdate(Primitive):
 
     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]:]`.
@@ -3978,7 +4093,7 @@ class ScatterMax(_ScatterOpDynamic):
 
     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`,
@@ -3997,7 +4112,7 @@ class ScatterMax(_ScatterOpDynamic):
                       and `updates` is greater than 8 dimensions.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> input_x = Parameter(Tensor(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]), mindspore.float32),
@@ -4036,7 +4151,7 @@ class ScatterMin(_ScatterOpDynamic):
 
     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`,
@@ -4097,7 +4212,7 @@ class ScatterAdd(Primitive):
 
     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`,
@@ -4213,7 +4328,7 @@ class ScatterSub(Primitive):
 
     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`,
@@ -4230,7 +4345,7 @@ class ScatterSub(Primitive):
                       is required when data type conversion of Parameter is not supported.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> input_x = Parameter(Tensor(np.array([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]), mindspore.float32), name="x")
@@ -4309,16 +4424,17 @@ class ScatterSub(Primitive):
 
 class Triu(Primitive):
     """
-    Returns the higher triangular part of a single Tensor,
-    the other elements of the result tensor out are set to 0.
-    The higher triangular part of the matrix is defined as the elements on and above the diagonal.
+    Returns the upper triangular portion of the 2-D matrix or the set of matrices
+    in a batch. The remaining elements of the resulting Tensor are assigned a value of 0.
+    The upper triangular section of the matrix comprises of the
+    elements present on and above the main diagonal.
 
     Args:
         diagonal (int, optional): The index of diagonal. Default: 0, indicating the main diagonal.
 
     Inputs:
-        - **x** (Tensor) -  The input tensor with shape :math:`(N,∗)`
-          where ∗ means any number of additional dimensions. The data type is Number.
+        - **x** (Tensor) - The input tensor with shape :math:`(N, *)`
+          where :math:`*` means any number of additional dimensions. The data type is Number.
 
     Outputs:
         - **y** (Tensor) - A tensor has the same shape and data type as input.
@@ -4329,7 +4445,7 @@ class Triu(Primitive):
         ValueError: If length of shape of x is less than 1.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([[ 1,  2,  3,  4],
@@ -4397,7 +4513,7 @@ class ScatterMul(_ScatterOpDynamic):
 
     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`,
@@ -4417,10 +4533,6 @@ class ScatterMul(_ScatterOpDynamic):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore import Tensor
-        >>> from mindspore import dtype as mstype
-        >>> import mindspore.ops as ops
-        >>> import numpy as np
         >>> 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)
@@ -4490,7 +4602,7 @@ class ScatterDiv(_ScatterOpDynamic):
     Using given values to update tensor value through the div 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.
 
-    for each `i, ..., j` in `indices.shape`:
+    for each :math:`i, ..., j` in `indices.shape`:
 
     .. math::
 
@@ -4506,7 +4618,7 @@ class ScatterDiv(_ScatterOpDynamic):
 
     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`,
@@ -4721,6 +4833,9 @@ class ScatterNdMul(_ScatterNdOp):
     Using given values to update parameter value through the multiplication 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.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Refer to :func:`mindspore.ops.scatter_nd_mul` for more details.
 
     Supported Platforms:
@@ -4767,6 +4882,9 @@ class ScatterNdDiv(_ScatterNdOp):
     Using given values to update tensor value through the division 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.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Refer to :func:`mindspore.ops.scatter_nd_div` for more details.
 
     Supported Platforms:
@@ -4854,6 +4972,11 @@ class ScatterNdMax(_ScatterNdOp):
           [1 1 1 1]]]
     """
 
+    @prim_attr_register
+    def __init__(self, use_locking=False):
+        """Initialize ScatterNdMax"""
+        super().__init__(use_locking)
+
 
 class ScatterNdMin(_ScatterNdOp):
     r"""
@@ -4902,6 +5025,11 @@ class ScatterNdMin(_ScatterNdOp):
           [10 10 10 10]]]
     """
 
+    @prim_attr_register
+    def __init__(self, use_locking=False):
+        """Initialize ScatterNdMin"""
+        super().__init__(use_locking)
+
 
 class ScatterNonAliasingAdd(Primitive):
     """
@@ -4977,7 +5105,7 @@ class SpaceToDepth(Primitive):
 
     Outputs:
         Tensor, the same data type as `x`. It must be a 4-D tensor. Tensor of shape
-        :math:`(N, ( C_{in} * \text{block_size} * 2), H_{in} / \text{block_size}, W_{in} / \text{block_size})`.
+        :math:`(N, (C_{in} * \text{block_size} * 2), H_{in} / \text{block_size}, W_{in} / \text{block_size})`.
 
     Raises:
         TypeError: If `block_size` is not an int.
@@ -5000,7 +5128,7 @@ class SpaceToDepth(Primitive):
     def __init__(self, block_size):
         """Initialize SpaceToDepth"""
         validator.check_value_type('block_size', block_size, [int], self.name)
-        validator.check('block_size', block_size, self.name, 2, Rel.GE)
+        validator.check('block_size', block_size, self.name, 2, validator.GE)
         self.block_size = block_size
         self.add_prim_attr("data_format", "NCHW")
         self.init_prim_io_names(inputs=['x'], outputs=['y'])
@@ -5053,7 +5181,7 @@ class DepthToSpace(Primitive):
     def __init__(self, block_size):
         """Initialize DepthToSpace"""
         validator.check_value_type('block_size', block_size, [int], self.name)
-        validator.check('block_size', block_size, '', 2, Rel.GE, self.name)
+        validator.check('block_size', block_size, '', 2, validator.GE, self.name)
         self.block_size = block_size
         self.add_prim_attr("data_format", "NCHW")
         self.init_prim_io_names(inputs=['x'], outputs=['y'])
@@ -5119,9 +5247,9 @@ class SpaceToBatch(Primitive):
         logger.warning("WARN_DEPRECATED: The usage of SpaceToBatch is deprecated."
                        " Please use SpaceToBatchND.")
         validator.check_value_type('block_size', block_size, [int], self.name)
-        validator.check('block_size', block_size, self.name, 2, Rel.GE, self.name)
+        validator.check('block_size', block_size, self.name, 2, validator.GE, self.name)
         self.block_size = block_size
-        validator.check('paddings shape', np.array(paddings).shape, self.name, (2, 2), Rel.EQ, self.name)
+        validator.check('paddings shape', np.array(paddings).shape, self.name, (2, 2), validator.EQ, self.name)
         for elem in itertools.chain(*paddings):
             validator.check_non_negative_int(elem, 'paddings element', self.name)
             validator.check_value_type('paddings element', elem, [int], self.name)
@@ -5149,8 +5277,8 @@ class BatchToSpace(PrimitiveWithInfer):
           product of `block_shape`. The data type is float16 or float32.
 
     Outputs:
-        Tensor, the output tensor with the same type as input. Assume input shape is (n, c, h, w) with block_size
-        and crops. The output shape will be (n', c', h', w'), where
+        Tensor, the output tensor with the same type as input. Assume input shape is :math:`(n, c, h, w)` with
+        block_size and crops. The output shape will be :math:`(n', c', h', w')`, where
 
         :math:`n' = n//(block\_size*block\_size)`
 
@@ -5186,7 +5314,7 @@ class BatchToSpace(PrimitiveWithInfer):
         logger.warning("WARN_DEPRECATED: The usage of BatchToSpace is deprecated."
                        " Please use BatchToSpaceND.")
         validator.check_value_type('block_size', block_size, [int], self.name)
-        validator.check('block_size', block_size, '', 2, Rel.GE, self.name)
+        validator.check('block_size', block_size, '', 2, validator.GE, self.name)
         self.block_size = block_size
         validator.check_value_type('crops type', crops, [list, tuple], self.name)
         validator.check('crops shape', np.array(crops).shape, self.name, (2, 2))
@@ -5205,7 +5333,7 @@ class BatchToSpace(PrimitiveWithInfer):
         for i in range(2):
             x_block_prod = out_shape[i + 2] * self.block_size
             crops_sum = self.crops[i][0] + self.crops[i][1]
-            validator.check("x block shape prod", x_block_prod, 'crops sum', crops_sum, Rel.GT, self.name)
+            validator.check("x block shape prod", x_block_prod, 'crops sum', crops_sum, validator.GT, self.name)
             out_shape[i + 2] = x_block_prod - crops_sum
         block_size_prod = self.block_size * self.block_size
         if out_shape[0] % block_size_prod != 0:
@@ -5249,9 +5377,11 @@ class SpaceToBatchND(Primitive):
         The shape of the output tensor will be :math:`(n', c_1, ... c_k, w'_1, ..., w'_M)`,
         where
 
-        :math:`n' = n*(block\_shape[0]*...*block\_shape[M-1])`
-
-        :math:`w'_i = (w_i+paddings[i-1][0]+paddings[i-1][1])//block\_shape[i-1]`
+        .. math::
+            \begin{array}{ll} \\
+                n' = n*(block\_shape[0]*...*block\_shape[M-1]) \\
+                w'_i = (w_i+paddings[i-1][0]+paddings[i-1][1])//block\_shape[i-1]
+            \end{array}
 
     Raises:
         TypeError: If `block_shape` is not one of list, tuple, int.
@@ -5282,24 +5412,25 @@ class SpaceToBatchND(Primitive):
     def __init__(self, block_shape, paddings):
         """Initialize SpaceToBatchND"""
         validator.check_value_type('paddings type', paddings, [list, tuple], self.name)
-        validator.check('paddings length', len(paddings), '', 1, Rel.GE, self.name)
+        validator.check('paddings length', len(paddings), '', 1, validator.GE, self.name)
 
         if isinstance(block_shape, int):
             block_shape = (block_shape,) * np.array(paddings).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), 'default value', 1, Rel.EQ, self.name)
+        validator.check('block_shape shape', len(np.array(block_shape).shape),
+                        'default value', 1, validator.EQ, self.name)
         block_rank = len(block_shape)
         if context.get_context("device_target") == "Ascend":
-            validator.check('block_shape length', block_rank, 'default value', 2, Rel.EQ, self.name)
+            validator.check('block_shape length', block_rank, 'default value', 2, validator.EQ, self.name)
         for elem in block_shape:
-            validator.check('block_shape element', elem, 'min value', 1, Rel.GE, self.name)
+            validator.check('block_shape element', elem, 'min value', 1, validator.GE, self.name)
             validator.check_value_type('block_shape element', elem, [int], self.name)
         self.block_shape = block_shape
 
         validator.check(
-            'paddings shape', np.array(paddings).shape, 'default value', (block_rank, 2), Rel.EQ, self.name)
+            'paddings shape', np.array(paddings).shape, 'default value', (block_rank, 2), validator.EQ, self.name)
         for elem in itertools.chain(*paddings):
             validator.check_non_negative_int(elem, 'paddings element', self.name)
             validator.check_value_type('paddings element', elem, [int], self.name)
@@ -5308,9 +5439,8 @@ class SpaceToBatchND(Primitive):
 
 class BatchToSpaceND(Primitive):
     r"""
-    Divides batch dimension with blocks and interleaves these blocks back into spatial dimensions.
-
-    Refer to :func:`mindspore.ops.batch_to_space_nd` for more details.
+    `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``
@@ -5326,6 +5456,7 @@ class BatchToSpaceND(Primitive):
            [3.  4.]]]]
     """
 
+    @deprecated("2.0", "ops.batch_to_space_nd", False)
     @prim_attr_register
     def __init__(self, block_shape, crops):
         """Initialize BatchToSpaceND"""
@@ -5333,18 +5464,18 @@ class BatchToSpaceND(Primitive):
             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, Rel.EQ, 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, Rel.EQ, self.name)
+            validator.check('block_shape length', block_rank, '', 2, validator.EQ, self.name)
         for elem in block_shape:
-            validator.check('block_shape element', elem, '', 1, Rel.GE, self.name)
+            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
 
         validator.check_value_type('crops type', crops, [list, tuple], self.name)
-        validator.check('crops length', len(crops), '', 1, Rel.GE, self.name)
-        validator.check('crops shape', np.array(crops).shape, '', (block_rank, 2), Rel.EQ, 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)
@@ -5356,6 +5487,9 @@ class BatchToSpaceNDV2(Primitive):
     Divides batch dimension with blocks and interleaves these blocks back into spatial dimensions.
 
     Refer to :func:`mindspore.ops.batch_to_space_nd` for more details.
+
+    Supported Platforms:
+        ``Ascend``
     """
 
     @prim_attr_register
@@ -5365,7 +5499,7 @@ class BatchToSpaceNDV2(Primitive):
         self.add_prim_attr('origin_format', 'NHWC')
 
 
-class BroadcastTo(Primitive):
+class BroadcastTo(PrimitiveWithCheck):
     """
     Broadcasts input tensor to a given shape.
 
@@ -5394,24 +5528,41 @@ class BroadcastTo(Primitive):
     def __init__(self, shape):
         """Initialize BroadcastTo"""
         validator.check_value_type("shape", shape, (tuple), self.name)
-        validator.check("dimension of x", len(shape), "", 0, Rel.GT, self.name)
+        validator.check("dimension of x", len(shape), "", 0, validator.GT, self.name)
         for ix, i in enumerate(shape):
             validator.check_value_type('target shape index -> ' + str(ix), i, [int], self.name)
-            validator.check("shape element", i, "shape element min limit", -1, Rel.GE, self.name)
+            validator.check("shape element", i, "shape element min limit", -1, validator.GE, self.name)
         self.shape = shape
 
+    def infer_value(self, x):
+        if x is None:
+            return None
+        return Tensor(np.broadcast_to(x.asnumpy(), self.shape))
+
 
 class Meshgrid(PrimitiveWithInfer):
     """
     Generates coordinate matrices from given coordinate tensors.
 
-    Given N one-dimensional coordinate tensors, returns a tuple outputs of N N-D
-    coordinate tensors for evaluating expressions on an N-D grid.
-
     Refer to :func:`mindspore.ops.meshgrid` for more details.
 
+    Args:
+        indexing (str, optional): Cartesian ('xy', default) 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
+            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.
+
+    Inputs:
+        - **input** (Union[tuple]) - A Tuple of N 1-D Tensor objects.
+          The length of input should be greater than 1. The data type is Number.
+
+    Outputs:
+        Tensors, A Tuple of N N-D Tensor objects. The data type is the same with the Inputs.
+
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([1, 2, 3, 4]).astype(np.int32))
@@ -5471,11 +5622,11 @@ class Meshgrid(PrimitiveWithInfer):
 
     def infer_shape(self, x_shape):
         validator.check_value_type("shape", x_shape, [tuple], self.name)
-        validator.check_int(len(x_shape), 2, Rel.GE, "len of input", self.name)
+        validator.check_int(len(x_shape), 2, validator.GE, "len of input", self.name)
         n = len(x_shape)
         shape_0 = []
         for s in x_shape:
-            validator.check_int(len(s), 1, Rel.EQ, 'each input rank', self.name)
+            validator.check_int(len(s), 1, validator.EQ, 'each input rank', self.name)
             shape_0.append(s[0])
         if self.indexing == "xy":
             shape_0[0], shape_0[1] = shape_0[1], shape_0[0]
@@ -5486,7 +5637,7 @@ class Meshgrid(PrimitiveWithInfer):
         validator.check_subclass("input[0]", x_type[0], mstype.tensor, 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], Rel.EQ, self.name, TypeError)
+            validator.check('x_type[%d]' % i, x_type[i], 'base', x_type[0], validator.EQ, self.name, TypeError)
         return x_type
 
 
@@ -5581,7 +5732,7 @@ class EditDistance(Primitive):
         \end{array}\right. &
         \end{array}\right.
 
-    Where the :math:`a` indicates the hypothesis and the :math:`a` indicates the truth. For ease of understanding,
+    Where the :math:`a` indicates the hypothesis and the :math:`b` indicates the truth. For ease of understanding,
     i and j here in may be considered as lengths of a and b.
 
     .. warning::
@@ -5695,7 +5846,7 @@ class Sort(Primitive):
 
     Outputs:
         - **y1** (Tensor) - A tensor whose values are the sorted values, with the same shape and data type as input.
-        - **y2** (Tensor) - The indices of the elements in the original input tensor. Data type is int32.
+        - **y2** (Tensor) - the indices of the elements in the original input tensor. Data type is int32.
 
     Raises:
         TypeError: If `axis` is not an int.
@@ -5754,7 +5905,7 @@ class EmbeddingLookup(PrimitiveWithCheck):
         ValueError: If length of shape of `input_params` is greater than 2.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> input_params = Tensor(np.array([[8, 9], [10, 11], [12, 13], [14, 15]]), mindspore.float32)
@@ -5848,11 +5999,11 @@ class IdentityN(Primitive):
     Return a tuple of tensors with the same shapes and contents as the input.
 
     This op can be used to override the gradient for complicated functions. For
-    example, suppose y = f(x) and we wish to apply a custom function g for backprop
-    such that dx = g(dy).
+    example, suppose :math:`y = f(x)` and we wish to apply a custom function g for backprop
+    such that :math:`dx=g(dy)`.
 
     Inputs:
-        - **x** (Tensors) - tuple(Tensor) or List(Tensor). The data type is RealNumber.
+        - **x** (Union[tuple[Tensor], list[Tensor]]) - Input, the data type is RealNumber.
 
     Outputs:
         Tensors - tuple(Tensor), the shape of tensor and the data type are the same as input `x`.
@@ -5862,7 +6013,7 @@ class IdentityN(Primitive):
         TypeError: If input `x` type is not RealNumber.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = [Tensor(np.array([1, 2, 3, 4]), mstype.int64), Tensor(np.array([4, 3, 1, 1]), mstype.int64)]
@@ -5883,14 +6034,30 @@ class IdentityN(Primitive):
 
 class Range(PrimitiveWithCheck):
     r"""
-    Creates a sequence of numbers that begins at `start` and extends by increments of
-    `delta` up to but not including `limit`. Length of the created sequence can not exceed `maxlen`.
-    The default value of `maxlen` is 1000000.
+    Creates a sequence of numbers that begins at `start` and extlimits by increments of
+    `delta` up to but not including `limit`.
 
     Refer to :func:`mindspore.ops.range` for more details.
 
+    Args:
+        maxlen (int, optional): Memory that can fit `maxlen` many elements
+            will be allocated for the output. Optional, must be positive, defaults to 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.
+
+    Outputs:
+       A 1-D Tensor, with the same type as the inputs.
+
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> start = Tensor(0, mstype.int32)
@@ -5910,9 +6077,12 @@ class Range(PrimitiveWithCheck):
         self.add_prim_attr('maxlen', maxlen)
 
     def check_shape(self, start_shape, limit_shape, delta_shape):
-        validator.check("start_shape", len(start_shape), "", 0, Rel.EQ, self.name)
-        validator.check("limit_shape", len(limit_shape), "", 0, Rel.EQ, self.name)
-        validator.check("delta_shape", len(delta_shape), "", 0, Rel.EQ, self.name)
+        if not is_shape_unknown(start_shape):
+            validator.check("start_shape", len(start_shape), "", 0, validator.EQ, self.name)
+        if not is_shape_unknown(limit_shape):
+            validator.check("limit_shape", len(limit_shape), "", 0, validator.EQ, self.name)
+        if not is_shape_unknown(delta_shape):
+            validator.check("delta_shape", len(delta_shape), "", 0, validator.EQ, self.name)
 
     def check_dtype(self, start_dtype, limit_dtype, delta_dtype):
         valid_dtypes = [mstype.int32, mstype.float32, mstype.int64, mstype.float64]
@@ -6093,14 +6263,33 @@ class MaskedSelect(PrimitiveWithCheck):
 
 class SearchSorted(Primitive):
     """
-    Find the indices from the innermost dimension of `sorted_sequence` such that the order of the innermost dimension
-    within `sorted_sequence` would be preserved when the corresponding values in `values` were inserted before the
-    indices.
+    Returns the indices correspond to the positions where the given numbers in `values` should be inserted
+    into `sorted_sequence` so that the order of the sequence is maintained.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Refer to :func:`mindspore.ops.searchsorted` for more details.
 
+    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.
+
+    Inputs:
+        - **sorted_sequence** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R-1, x_R)` or `(x_1)`.
+          It must contain a monotonically increasing sequence on the innermost dimension.
+        - **values** (Tensor) - The value that should be inserted.
+          The shape of tensor is :math:`(x_1, x_2, ..., x_R-1, x_S)`.
+
+    Outputs:
+        Tensor containing the indices from the innermost dimension of `sorted_sequence` such that,
+        if insert the corresponding value in the `values` tensor, the order of `sorted_sequence` would be preserved,
+        whose datatype is int32 if out_int32 is True, otherwise int64, and shape is the same as the shape of `values`.
+
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> sorted_sequence = Tensor(np.array([[0, 1, 3, 5, 7], [2, 4, 6, 8, 10]]), mindspore.float32)
@@ -6187,12 +6376,11 @@ class TensorScatterUpdate(_TensorScatterOp):
 
     Inputs:
         - **input_x** (Tensor) - The target 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 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]:]`
 
     Outputs:
@@ -6202,6 +6390,7 @@ class TensorScatterUpdate(_TensorScatterOp):
         TypeError: If dtype of `indices` is neither int32 nor int64.
         ValueError: If length of shape of `input_x` is less than the last dimension of shape of `indices`.
         ValueError: If the value of `input_x` are not match with input `indices`.
+        RuntimeError: If a value of `indices` is not in `input_x`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -6219,7 +6408,6 @@ class TensorScatterUpdate(_TensorScatterOp):
 
     @prim_attr_register
     def __init__(self):
-        super().__init__("TensorScatterUpdate")
         self.init_prim_io_names(inputs=['input_x', 'indices', 'updates'], outputs=['y'])
 
     def _infer_specified_value(self, input_x_value, indices_value, updates_value):
@@ -6289,7 +6477,6 @@ class TensorScatterMax(Primitive):
 
     @prim_attr_register
     def __init__(self):
-        super().__init__("TensorScatterMax")
         self.init_prim_io_names(inputs=['input_x', 'indices', 'updates'], outputs=['y'])
 
 
@@ -6325,7 +6512,6 @@ class TensorScatterMin(Primitive):
 
     @prim_attr_register
     def __init__(self):
-        super().__init__("TensorScatterMin")
         self.init_prim_io_names(inputs=['input_x', 'indices', 'updates'], outputs=['y'])
 
 
@@ -6363,7 +6549,6 @@ class TensorScatterSub(Primitive):
 
     @prim_attr_register
     def __init__(self):
-        super().__init__("TensorScatterSub")
         self.init_prim_io_names(inputs=['input_x', 'indices', 'updates'], outputs=['y'])
 
 
@@ -6402,7 +6587,6 @@ class TensorScatterAdd(Primitive):
 
     @prim_attr_register
     def __init__(self):
-        super().__init__("TensorScatterAdd")
         self.init_prim_io_names(inputs=['input_x', 'indices', 'updates'], outputs=['y'])
 
 
@@ -6440,7 +6624,6 @@ class TensorScatterMul(_TensorScatterOp):
 
     @prim_attr_register
     def __init__(self):
-        super().__init__("TensorScatterMul")
         self.init_prim_io_names(inputs=['input_x', 'indices', 'updates'], outputs=['y'])
 
 
@@ -6478,43 +6661,42 @@ class TensorScatterDiv(_TensorScatterOp):
 
     @prim_attr_register
     def __init__(self):
-        super().__init__("TensorScatterDiv")
         self.init_prim_io_names(inputs=['input_x', 'indices', 'updates'], outputs=['y'])
 
 
 class ListDiff(Primitive):
-    r"""Computes the difference between two lists of numbers.
+    r"""
+    This function calculates the disparity between two numerical lists.
 
-    Given a list `x` and a list `y`, this operation returns a list `out` that
-    represents all values that are in `x` but not in `y`. The returned list `out`
-    is sorted in the same order that the numbers appear in `x` (duplicates are
-    preserved). This operation also returns a list `idx` that represents the
-    position of each `out` element in `x`. In other words:
+    It generates a list of all elements that are present in list `x` but not in list `y`.
+    The output list `out` retains the same order as the original `x` including duplicate elements.
+
+    Additionally, this class outputs a list `idx` that identifies the position of each element
+    in `out` within the original `x`. That is to say:
     :code:`out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]` .
 
     Args:
         out_idx (:class:`mindspore.dtype`, optional): The dtype of `idx`,
-            an optioanal datatype of `mindspore.dtype.int32` and `mindspore.dtype.int64`.
-            Default: `mindspore.dtype.int32`.
+            an optioanal datatype of `mstype.int32` and `mstype.int64`.
+            Default: `mstype.int32`.
 
     Inputs:
-        - **x** - A 1-D `Tensor`. Values to keep. type support list [float16, float32,
-          float64, uint8, uint16, int8, int16, int32, int64]
-        - **y** - A 1-D `Tensor`. Must have the same type as `x`. 1-D. Values to remove.
+        - **x** - Values to keep. A 1-D `Tensor`.
+        - **y** - Values to remove. A 1-D `Tensor`. Must have the same type as `x`. 1-D.
 
     Outputs:
-        - **out** - A 1-D `Tensor`. Has the same type as `x`.
-        - **idx** - A 1-D `Tensor` of type `out_idx`.
+        - **out** - The kept values. A 1-D `Tensor`. Has the same type as `x`.
+        - **idx** - The original index of kept values. A 1-D `Tensor` of type `out_idx`.
 
     Raises:
         ValueError: If `x` or `y` shape is not 1D.
         TypeError: If `x` or `y` is not a Tensor.
-        TypeError: If `x` or `y` datetype not in support list.
+        TypeError: If `x` or `y` date type is not int or uint.
         TypeError: If `x` has different data type with `y`.
-        TypeError: If attr `out_idx` not in [mindspore.dtype.int32, mindspore.dtype.int64].
+        TypeError: If attr `out_idx` not in [mstype.int32, mstype.int64].
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.arange(1, 7, 1), dtype=mindspore.dtype.int32) # [1, 2, 3, 4, 5, 6]
@@ -6532,7 +6714,8 @@ class ListDiff(Primitive):
         """Initialize ListDiff"""
         self.init_prim_io_names(inputs=['x', 'y'], outputs=['out', 'idx'])
         validator.check_value_type("out_idx", out_idx, [mstype.Type], self.name)
-        validator.check("out_idx", out_idx, "", [mstype.int32, mstype.int64], Rel.IN, self.name, excp_cls=TypeError)
+        validator.check("out_idx", out_idx, "", [mstype.int32, mstype.int64], validator.IN,
+                        self.name, excp_cls=TypeError)
         self.out_idx = out_idx
         self.add_prim_attr('out_idx', out_idx)
 
@@ -6545,7 +6728,7 @@ class SplitV(Primitive):
     by `size_splits` along the split dimension. This requires that `input_x.shape(split_dim)`
     is equal to the sum of `size_splits`.
 
-    The shape of `input_x` is :math:`(x_1, x_2, ..., x_M, ..., x_R)`. The rank of `input_x`
+    The shape of `input_x` is :math:`(x_1, x_2, ..., x_M, ..., x_R)` whose rank
     is `R`. Set the given `split_dim` as M, and :math:`-R \le M < R`. Set the given `num_split`
     as `N`, the given `size_splits` as :math:`(x_{m_1}, x_{m_2}, ..., x_{m_N})`,
     :math:`x_M=\sum_{i=1}^Nx_{m_i}`. The output is a list of tensor objects, for the
@@ -6559,11 +6742,12 @@ class SplitV(Primitive):
          (x_1, x_2, ..., x_{m_N}, ..., x_R))
 
     Args:
-        size_splits (Union[tuple, list]): The list containing the sizes of each output tensor
-            along the split dimension. Must sum to the dimension of value along `split_dim`.
-            Can contain one -1 indicating that dimension is to be inferred.
-        split_dim (int): The dimension along which to split. Must be in the range [-len(input_x.shape),
-            len(input_x.shape)).
+        size_splits (Union[tuple, list]): A tuple or list of sizes of each output tensor along the split
+            dimension, and the sum of these sizes should equal to the dimension of the
+            input tensor along `split_dim`. The list may also contain a single instance of
+            the value -1, which indicates that the size of that dimension should be inferred.
+        split_dim (int): An int indicates the dimension along which to split.
+            Must be in the range [-len(input_x.shape), len(input_x.shape)).
         num_split (int): The number of output tensors. Must be positive int.
 
     Inputs:
@@ -6626,16 +6810,16 @@ class SplitV(Primitive):
 
 class TensorScatterElements(Primitive):
     """
-    Updates the value of the output tensor through the reduction operation.
+    Updates the value of the input Tensor through specified reduction operation.
+
     Refer to :func:`mindspore.ops.tensor_scatter_elements` for more details.
 
     .. warning::
-        The order in which updates are applied is nondeterministic, meaning that 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.
+        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.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> op = ops.TensorScatterElements(0, "none")
@@ -6684,7 +6868,7 @@ class ExtractVolumePatches(Primitive):
         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:`(x_n, x_c, x_d, x_h, x_w)`.
+        - **input_x** (Tensor) - A Tensor. 5-D Tensor with shape :math:`()`.
 
     Outputs:
         Tensor, has the same type as input.
@@ -6703,11 +6887,11 @@ class ExtractVolumePatches(Primitive):
         ValueError: If input_x is not a tensor in dimension 5.
         ValueError: If input_x's shape has zero.
         ValueError: If one of kernel_size or strides' first two numbers is not 1.
-        ValueError: If padding = "VALID" and input - kernel_size is less than 0 in d, h or w dimension.
+        ValueError: If padding = "VALID" and :math:`input\_x - kernel\_size` is less than 0 in d, h or w dimension.
         ValueError: If padding = "SAME" and :math:`padding\_needed = ((input\_x + strides - 1) / strides - 1) *
-                    strides + kernel\_size - input` is less than 0 in d, h or w dimension.
-        ValueError: If x_h is not 1 or x_w is not 1 and x_w + padding_needed - k_w - s_w is less than 0.
-        ValueError: If x_d * x_h * x_w is greater than 2048.
+                    strides + kernel\_size - input\_x` is less than 0 in d, h or w dimension.
+        ValueError: If x_h is not 1 or x_w is not 1 and :math:`x_w + padding\_needed - k_w - s_w` is less than 0.
+        ValueError: If :math:`x_d * x_h * x_w` is greater than 2048.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -6729,13 +6913,13 @@ class ExtractVolumePatches(Primitive):
         if isinstance(kernel_size, (list, tuple)):
             kernel_size = tuple(kernel_size)
             if len(kernel_size) == 5:
-                validator.check_int(kernel_size[0], 1, Rel.EQ, "kernel_size[0]", self.name)
-                validator.check_int(kernel_size[1], 1, Rel.EQ, "kernel_size[1]", self.name)
+                validator.check_int(kernel_size[0], 1, validator.EQ, "kernel_size[0]", self.name)
+                validator.check_int(kernel_size[1], 1, validator.EQ, "kernel_size[1]", self.name)
         if isinstance(strides, (list, tuple)):
             strides = tuple(strides)
             if len(strides) == 5:
-                validator.check_int(strides[0], 1, Rel.EQ, "strides[0]", self.name)
-                validator.check_int(strides[1], 1, Rel.EQ, "strides[1]", self.name)
+                validator.check_int(strides[0], 1, validator.EQ, "strides[0]", self.name)
+                validator.check_int(strides[1], 1, validator.EQ, "strides[1]", self.name)
         self.kernel_size = _check_3d_int_or_tuple("kernel_size", kernel_size, self.name,
                                                   allow_five=True, ret_five=True, greater_zero=True)
         self.strides = _check_3d_int_or_tuple("strides", strides, self.name,
@@ -6749,31 +6933,11 @@ class ExtractVolumePatches(Primitive):
 
 class ScatterAddWithAxis(Primitive):
     """
-    The output of the operation is produced by creating a copy of the input input_x, and then
-    add updating its value to values specified by `updates` at specific index positions specified
-    by `indices`.
-
-    Note:
-        The three inputs `input_x`, `updates` and `indices` must have the same rank r >= 1.
-
-    Args:
-        axis (int, optional): Specifies which axis to do scatter add, default: 0.
-
-    Inputs:
-        - **input_x** (Tensor) - The target tensor to be added.
-        - **indices** (Tensor) - The index of input tensor whose data type is int32 or int64.
-        - **updates** (Tensor) - The Tensor to update the `input_x`, has the same type as `input_x`
-          and the same shape as `indices`.
-
-    Outputs:
-        Tensor, the updated `input_x`, has the same shape and type as `input_x`.
-
-    Raises:
-        TypeError: If dtype of `indices` is neither int32 nor int64.
-        ValueError: If the shape of `indices` is not equal to the shape of `updates`.
+    'ops.ScatterAddWithAxis' is deprecated from version 2.0 and will be removed in a future version,
+    use 'ops.TensorScatterElements' instead.
 
     Supported Platforms:
-        ``CPU``
+        Deprecated
 
     Examples:
         >>> op = ops.ScatterAddWithAxis(0)
@@ -6799,6 +6963,7 @@ class ScatterAddWithAxis(Primitive):
         sig.make_sig('updates', dtype=sig.sig_dtype.T)
     )
 
+    @deprecated("2.0", "ops.TensorScatterElements", False)
     @prim_attr_register
     def __init__(self, axis=0):
         """Initialize ScatterAddWithAxis"""
@@ -6817,7 +6982,7 @@ class Lstsq(Primitive):
     .. math::
 
        \begin{array}{ll}
-       \min_y & \|xy-a\|_2.
+       \min_y & \|xy-a\|_2
        \end{array}
 
     If :math:`m < n`, `Lstsq` solves the least-norm problem:
@@ -6825,7 +6990,7 @@ class Lstsq(Primitive):
     .. math::
 
        \begin{array}{llll}
-       \min_y & \|y\|_2 & \text{subject to} & xy = a.
+       \min_y & \|y\|_2 & \text{subject to} & xy = a
        \end{array}
 
     Args:
@@ -6834,14 +6999,14 @@ class Lstsq(Primitive):
             - 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
-              completee orthogonal decomposition is used.
+              completed orthogonal decomposition is used.
 
         l2_regularizer (float, optional): L2 regularization coefficient. Default: 0.0.
 
     Inputs:
-        - **x** (Tensor) - The m by n matrix `x`. The input tensor whose data type is
+        - **x** (Tensor) - :math:`(m \times n)` matrix `x`. The input tensor whose data type is
           float16, float32 or float64.
-        - **a** (Tensor) - The m by k matrix `a`. The input tensor whose data type is
+        - **a** (Tensor) - :math:`(m \times k)` matrix `a`. The input tensor whose data type is
           float16, float32 or float64.
 
     Outputs:
@@ -6881,8 +7046,7 @@ class Lstsq(Primitive):
 
 class LowerBound(Primitive):
     """
-    Returns a tensor that contains the index for finding the lower bound of the value
-    of the input values element in the input sorted_x.
+    Find the index of the lower bound of `values` in sorted sequence `sorted_x` element-wise.
 
     Args:
         out_type (:class:`mindspore.dtype`, optional): An optional data type of
@@ -6910,7 +7074,7 @@ class LowerBound(Primitive):
         ValueError: If the first dimension of the shape of `sorted_x` is not equal to that of `values`.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore
@@ -6963,7 +7127,7 @@ class UpperBound(Primitive):
         ValueError: If the number of rows of `sorted_x` is not consistent with that of `values`.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore
@@ -7037,9 +7201,12 @@ class RightShift(Primitive):
         &out_{i} =x_{i} >> y_{i}
         \end{aligned}
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Inputs:
         - **input_x** (Tensor) - The target tensor, will be shifted to the right
-          by y in element-wise.
+          by `input_y` bits element-wise.
         - **input_y** (Tensor) - Number of bits shifted, the tensor must have the same type as `input_x`.
 
     Outputs:
@@ -7069,9 +7236,10 @@ class RightShift(Primitive):
 
 class LogSpace(Primitive):
     r"""
-    Returns a one-dimensional tensor of size steps whose values are evenly
-    spaced from :math:`base^{start}` to :math:`base^{end}` , inclusive,
-    on a logarithmic scale with base.
+    Generates a 1-D Tensor with a length of steps. The tensor's
+    values are uniformly distributed on a logarithmic scale, ranging from
+    :math:`base^{start}` to :math:`base^{end}`, including both endpoints.
+    The logarithmic scale is based on the specified `base`.
 
     .. math::
         \begin{aligned}
@@ -7079,33 +7247,36 @@ class LogSpace(Primitive):
         &output = [base^{start}, base^{start + 1 * step}, ... , base^{start + (steps-2) * step}, base^{end}]
         \end{aligned}
 
+    .. warning::
+        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(for GPU). Default: mindspore.float32.
+            mindspore.float32 or mindspore.float64. Default: mindspore.float32.
 
 
     Inputs:
         - **start** (Tensor) - Start value of interval, with shape of 0-D,
-          dtype is float16, float32 or float64(for GPU).
+          dtype is float16, float32 or float64.
         - **end** (Tensor) - End value of interval, with shape of 0-D,
-          dtype is float16, float32 or float64(for GPU).
+          dtype is float16, float32 or float64.
 
     Outputs:
-        Tensor has the shape as (step, ). Its datatype is set by the attr 'dtype'.
+        Tensor has the shape as :math:`(step, )`. Its datatype is set by the attr 'dtype'.
 
     Raises:
         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(for GPU).
+            mindspore.float64.
         ValueError: If `steps` is not a non-negative integer.
         ValueError: If `base` is not a non-negative integer.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> logspace = ops.LogSpace(steps = 10, base = 10, dtype=mindspore.float32)
@@ -7149,6 +7320,13 @@ class NonZero(Primitive):
         >>> print(output)
         [[0 0 0]
          [0 1 0]]
+        >>> x = Tensor(np.array([1, 0, 2, 0, 3]), mindspore.int32)
+        >>> nonzero = NonZero()
+        >>> output = nonzero(x)
+        >>> print(output)
+        [[0]
+         [2]
+         [4]]
     """
 
     @prim_attr_register
@@ -7158,9 +7336,13 @@ class NonZero(Primitive):
 
 class Tril(Primitive):
     """
-    Returns the lower triangular part of the matrix (2-D tensor) or batch of matrices input,
-    the other elements of the result tensor out are set to 0.
-    The lower triangular part of the matrix is defined as the elements on and below the diagonal.
+    Returns the lower triangular portion of the 2-D matrix or the set of matrices
+    in a batch. The remaining elements of the resulting Tensor are assigned a value of 0.
+    The lower triangular section of the matrix comprises of the
+    elements present on and below the main diagonal.
+
+    .. warning::
+        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,
@@ -7227,13 +7409,16 @@ class Tril(Primitive):
 
 class IndexFill(Primitive):
     """
-    Fills the elements under the dim dimension of the input Tensor with the input value
-    by selecting the indices in the order given in index.
+    Fills the elements under the `dim` dimension of the input Tensor `x` with the input `value`
+    by selecting the indices in the order given in `index`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Refer to :func:`mindspore.ops.index_fill` for more details.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> index_fill = ops.IndexFill()
@@ -7253,12 +7438,68 @@ class IndexFill(Primitive):
         self.init_prim_io_names(inputs=['x', 'dim', 'index', 'value'], outputs=['y'])
 
 
+class IndexPut(Primitive):
+    r"""
+    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.
+    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
+        - **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.
+
+    Outputs:
+        The Tensor to be assigned. Should be of the same type 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.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> 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))]
+        >>> accumulate = 1
+        >>> op = ops.IndexPut(accumulate = accumulate)
+        >>> output = op(x1, x2, indices)
+        >>> print(output)
+         [[4 5 3]
+         [4 5 6]]
+    """
+
+    @prim_attr_register
+    def __init__(self, accumulate=0):
+        self.accumulate = accumulate
+        validator.check_value_type('accumulate', accumulate, [int], self.name)
+        self.init_prim_io_names(inputs=['x1', 'x2', 'indices'], outputs=['y'])
+
+
 class SegmentMax(Primitive):
     r"""
-    Computes the maximum along segments of a tensor.
+    Computes the maximum along segments of a Tensor.
 
-    Computes a tensor such that :math:`output_i=max_j(input\_x_j)` where max is over :math:`j` such that
-    :math:`segment\_ids[j] == i`. If the max is empty for a given segment ID :math:`i`, :math:`output[i] = 0`.
+    Specifically, it generates a new Tensor `output` such that :math:`output_i=max_j(input\_x_j)`
+    in which the maximum value is obtained from all elements corresponding
+    to :math:`j` that meets :math:`segment\_ids[j] == i`.
+    If a segment contains no elements for a given segment :math:`i`,
+    then the corresponding element in the output Tensor is set to zero: :math:`output[i] = 0`.
 
     Inputs:
         - **input_x** (Tensor) - The input tensor whose dtype is real number and whose rank is not less than 1.
@@ -7283,7 +7524,7 @@ class SegmentMax(Primitive):
         ValueError: If the values of `segment_ids` are not sorted in ascending order.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], mstype.float64)
@@ -7305,10 +7546,13 @@ class SegmentMax(Primitive):
 
 class SegmentMin(Primitive):
     r"""
-    Computes the minimum along segments of a tensor.
+    Computes the minimum along segments of a Tensor.
 
-    Computes a tensor such that :math:`output_i=min_j(input\_x_j)` where :math:`min` is over :math:`j` such that
-    :math:`segment\_ids[j] == i`. If the min is empty for a given segment ID :math:`i`, :math:`output[i] = 0`.
+    Specifically, it generates a new Tensor `output` such that :math:`output_i=min_j(input\_x_j)`
+    in which the minimum value is obtained from all elements corresponding
+    to :math:`j` that meets :math:`segment\_ids[j] == i`.
+    If a segment contains no elements for a given segment :math:`i`,
+    then the corresponding element in the output Tensor is set to zero: :math:`output[i] = 0`.
 
     Inputs:
         - **input_x** (Tensor) - The input tensor whose dtype is real number and whose rank is not less than 1.
@@ -7333,7 +7577,7 @@ class SegmentMin(Primitive):
         ValueError: If the values of `segment_ids` are not sorted in ascending order.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], mstype.float64)
@@ -7355,10 +7599,13 @@ class SegmentMin(Primitive):
 
 class SegmentSum(Primitive):
     r"""
-    Computes the sum along segments of a tensor.
+    Computes the cumulative sum along segments of a Tensor.
 
-    Computes a tensor such that :math:`output_i = \sum_j input\_x_j` where sum is over :math:`j` such that
-    :math:`segment\_ids[j] == i`. If the sum is empty for a given segment ID :math:`i`, :math:`output[i] = 0`.
+    Specifically, it generates a new Tensor `output` such that :math:`output_i = \sum_j input\_x_j`
+    in which the cumulative sum is obtained from all elements corresponding
+    to :math:`j` that meets :math:`segment\_ids[j] == i`.
+    If a segment contains no elements for a given segment :math:`i`,
+    then the corresponding element in the output Tensor is set to 0: :math:`output[i] = 0`.
 
     .. warning::
         If the dtype of `input_x` is complex number, the gradient can not be calculated.
@@ -7387,7 +7634,7 @@ class SegmentSum(Primitive):
         ValueError: If the values of `segment_ids` are not sorted in ascending order.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], mstype.float64)
@@ -7420,6 +7667,9 @@ class LeftShift(Primitive):
         &out_{i} =x_{i} << y_{i}
         \end{aligned}
 
+    .. warning::
+        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.
@@ -7437,7 +7687,7 @@ class LeftShift(Primitive):
         ValueError: If `x1` and `x2` could not be broadcast.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> left_shift = ops.LeftShift()
@@ -7456,20 +7706,23 @@ class LeftShift(Primitive):
 
 class FillDiagonal(Primitive):
     """
-    Fill the main diagonal of a tensor that has at least 2-dimensions.
-    When dims>2, all dimensions of input must be of equal length.
-    This function modifies the input tensor in-place, and returns the input tensor.
+    Fills the main diagonal of a Tensor in-place with a specified value and returns the result.
+    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.
 
     Args:
-        fill_value (float): The fill value.
-        wrap (bool, optional): the diagonal `wrapped` after N columns for tall matrices. Default: False.
+        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.
 
     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 `x`.
+        - **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.
@@ -7477,7 +7730,7 @@ class FillDiagonal(Primitive):
         ValueError: If the size of each dimension is not equal, when the dimension is greater than 2.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]).astype(np.float32))
@@ -7534,6 +7787,9 @@ class HammingWindow(Primitive):
 
     where :math:`N` is the full window size.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Args:
         periodic (bool, optional): a flag determines whether the returned window trims off
             the last duplicate value from the symmetric window. Default: True.
@@ -7544,14 +7800,14 @@ class HammingWindow(Primitive):
 
         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 `mindspore.dtype.float16`,
-            `mindspore.dtype.float32` and `mindspore.dtype.float64`. Default: `mindspore.dtype.float32`.
+        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.
 
     Outputs:
-        Tensor, A 1-D tensor containing the window, whose shape is :math:`\text{length}`.
+        Tensor, A 1-D tensor containing the window, whose shape is :math:`(\text{length},)`.
 
     Raises:
         TypeError: If `length` is not a Tensor.
@@ -7564,7 +7820,7 @@ class HammingWindow(Primitive):
         ValueError: If data of `length` is negative.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> # case 1: periodic=True.
@@ -7601,12 +7857,15 @@ class HammingWindow(Primitive):
 
 class AffineGrid(Primitive):
     r"""
-    Generates a 2D or 3D flow field (sampling grid), given a batch of affine matrices theta.
+    Creates a 2D or 3D flow field (sampling grid) based on a batch of affine matrices `theta`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Refer to :func:`mindspore.ops.affine_grid` for more details.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> affinegrid = ops.AffineGrid(align_corners=False)
@@ -7631,10 +7890,13 @@ class AffineGrid(Primitive):
 
 class SegmentMean(Primitive):
     r"""
-    Computes the mean along segments of a tensor.
+    Computes the mean along segments of a Tensor.
 
-    Computes a tensor such that :math:`output_i = mean_j(input\_x_j)` where mean is over :math:`j` such that
-    :math:`segment\_ids[j] == i`. If the mean is empty for a given segment ID :math:`i`, :math:`output[i] = 0`.
+    Specifically, it generates a new Tensor `output` such that :math:`output_i=mean_j(input\_x_j)`
+    in which the mean value is obtained from all elements corresponding
+    to :math:`j` that meets :math:`segment\_ids[j] == i`.
+    If a segment contains no elements for a given segment :math:`i`,
+    then the corresponding element in the output Tensor is set to zero: :math:`output[i] = 0`.
 
     .. warning::
         If the dtype of `input_x` is complex number, the gradient can not be calculated.
@@ -7663,7 +7925,7 @@ class SegmentMean(Primitive):
         ValueError: If the values of `segment_ids` are not sorted in ascending order.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor([[1, 2, 3], [1, 2, 3], [7, 8, 9]], mstype.float64)
@@ -7685,10 +7947,13 @@ class SegmentMean(Primitive):
 
 class SegmentProd(Primitive):
     r"""
-    Computes the prod along segments of a tensor.
+    Computes the cumulative product along segments of a Tensor.
 
-    Computes a tensor such that :math:`output_i = \prod_j input\_x_j` where prod is over :math:`j` such that
-    :math:`segment\_ids[j] == i`. If the prod is empty for a given segment ID :math:`i`, :math:`output[i] = 0`.
+    Specifically, it generates a new Tensor `output` such that :math:`output_i = \prod_j input\_x_j`
+    in which the cumulative product is obtained from all elements corresponding
+    to :math:`j` that meets :math:`segment\_ids[j] == i`.
+    If a segment contains no elements for a given segment :math:`i`,
+    then the corresponding element in the output Tensor is set to 1: :math:`output[i] = 1`.
 
     .. warning::
         If the dtype of `input_x` is complex number, the gradient can not be calculated.
@@ -7717,7 +7982,7 @@ class SegmentProd(Primitive):
         ValueError: If the values of `segment_ids` are not sorted in ascending order.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], mstype.float64)
@@ -7763,7 +8028,44 @@ class TopK(Primitive):
     """
     Finds values and indices of the `k` largest entries along the last dimension.
 
-    Refer to :func:`mindspore.ops.top_k` for more details.
+    .. warning::
+        - If sorted is set to False, it will use the aicpu operator, the performance may be reduced. In addition, due to
+          different memory layout and traversal methods on different platforms, the display order of calculation results
+          may be inconsistent when `sorted` is False.
+
+    If the `input_x` is a one-dimensional Tensor, finds the `k` largest entries in the Tensor,
+    and outputs its value and index as a Tensor. values[`k`] is the `k` largest item in `input_x`,
+    and its index is indices [`k`].
+
+    For a multi-dimensional matrix,
+    calculates the first `k` entries in each row (corresponding vector along the last dimension), therefore:
+
+    .. math::
+
+        values.shape = indices.shape = input.shape[:-1] + [k].
+
+    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.
+
+    Inputs:
+        - **input_x** (Tensor) - Input to be computed, data type must be float16, float32 or int32 on CPU,
+          and float16 or float32 on GPU.
+        - **k** (int) - The number of top elements to be computed along the last dimension, constant input is needed.
+
+    Outputs:
+        A tuple consisting of `values` and `indexes`.
+
+        - **values** (Tensor) - The `k` largest elements in each slice of the last dimension.
+        - **indices** (Tensor) - The indices of values within the last dimension of input.
+
+    Raises:
+        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.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -7793,8 +8095,11 @@ class Bincount(Primitive):
     """
     Counts the number of occurrences of each value in an integer array.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Inputs:
-        - **array** (Tensor) - A Tensor of type int32.
+        - **array** (Tensor) - A Tensor of type int32, whose value can not be less than zero.
         - **size** (Tensor) - A non-negative Tensor of type int32.
         - **weights** (Tensor) - A Tensor with the same shape as array, or a length-0 Tensor, in which case it acts as
           all weights equal to 1. Must be one of the following types: int32, int64, float32, float64.
@@ -7827,3 +8132,33 @@ class Bincount(Primitive):
     def __init__(self):
         """Initialize Bincount"""
         self.init_prim_io_names(inputs=['array', 'size', 'weights'], outputs=['bins'])
+
+
+class CountNonZero(Primitive):
+    """
+    Calculates the total number of non-zero entries in the input tensor along the
+    specified dimensions.
+
+    Refer to :func:`mindspore.ops.count_nonzero` for more details.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> x = Tensor([[0, 0, 1], [1, 1, 2], [0, 0, 1]], dtype=mindspore.int64)
+        >>> countnonzero = ops.CountNonZero(dims=[1])
+        >>> y = countnonzero(x)
+        >>> print(y)
+        [1 3 1]
+    """
+
+    @prim_attr_register
+    def __init__(self, dims=None):
+        dims = [] if dims is None else dims
+        self.init_prim_io_names(inputs=['x'], outputs=['y'])
+        validator.check_value_type('dims', dims, [int, list, tuple], "CountNonZero")
+        if isinstance(dims, (list, tuple)):
+            for i, each in enumerate(dims):
+                validator.check_value_type(f'dims[{i}]', each, [int], "CountNonZero")
+        self.dims = dims
+        self.add_prim_attr("dims", self.dims)