mindspore 2.4.10__cp310-cp310-win_amd64.whl → 2.6.0__cp310-cp310-win_amd64.whl

mindspore/ops/operations/array_ops.py

@@ -32,17 +32,18 @@ from mindspore._checkparam import _check_3d_int_or_tuple
 from mindspore.common import dtype as mstype
 from mindspore.common._decorator import deprecated
 from mindspore.common import Tensor, CSRTensor, COOTensor
-from mindspore._c_expression import Tensor as Tensor_
+from mindspore._c_expression import TensorPy as Tensor_
 from mindspore._c_expression import CSRTensor as CSRTensor_
 from mindspore._c_expression import COOTensor as COOTensor_
-from ..auto_generate import (ExpandDims, Reshape, TensorShape, Transpose, Gather,
-                             OnesLike, ZerosLike, Argmax, ArgMaxExt,
-                             ReverseV2, Diag, Eye, ScatterNd, ResizeNearestNeighborV2,
-                             GatherNd, GatherD, Range, MaskedFill, RightShift, NonZero,
-                             ResizeNearestNeighbor, Identity, Split, CumSum, CumProd, MaskedSelect,
-                             Cummax, Cummin, Argmin, Concat, UnsortedSegmentSum, ScalarToTensor,
-                             Triu, BroadcastTo, StridedSlice, Select, TopkExt, SearchSorted)
-from .manually_defined import Rank, Shape, Tile, Cast, Ones, Zeros
+from ..auto_generate import (
+    ExpandDims, Reshape, TensorShape, Transpose, TransposeView, Gather, OnesLike, ZerosLike,
+    Argmax, ArgMaxExt, ReverseV2, Diag, Eye, ScatterNd,
+    ResizeNearestNeighborV2, GatherNd, GatherD, Range, MaskedFill, RightShift,
+    NonZero, ResizeNearestNeighbor, Identity, Split, CumSum, CumProd,
+    MaskedSelect, Cummax, Cummin, Argmin, Concat, UnsortedSegmentSum, UniqueConsecutive,
+    ScalarToTensor, Triu, BroadcastTo, StridedSlice, Select, TopkExt,
+    SearchSorted, Meshgrid, Squeeze, Slice, TransposeExtView)
+from .manually_defined import Rank, Shape, Tile, Cast, Ones, Zeros, TypeAs
 from ..auto_generate import ArgMaxWithValue, ArgMinWithValue
 from ..auto_generate import TensorScatterElements as TensorScatterElementsExt
 
@@ -182,8 +183,7 @@ def _check_infer_attr_reduce(axis, keep_dims, prim_name):
 
 class Expand(Primitive):
     """
-    :class:`mindspore.ops.Expand` will be deprecated in the future.
-    Please use :class:`mindspore.ops.BroadcastTo` instead.
+    This interface will be deprecated in the future, and use :class:`mindspore.ops.BroadcastTo` instead.
     """
 
     @deprecated("2.1", "BroadcastTo", False)
@@ -273,7 +273,7 @@ class Im2Col(Primitive):
     each sliding `ksizes`- sized block within the spatial dimensions
     of input `x` into a column (i.e., last dimension) of a 4-D output
     tensor of shape :math:`(N, C, \prod(\text{kernel_size}), L)`, where
-    :math:`C \times \prod(\text{kernel_size})` is the total number of values
+    :math:`C \times \prod(\text{kernel_size})` is the total number of elements
     within each block (a block has :math:`\prod(\text{kernel_size})` spatial
     locations each containing a `C`-channeled vector), and :math:`L` is
     the total number of such blocks:
@@ -474,52 +474,6 @@ class Unsqueeze(PrimitiveWithCheck):
         self.axis = axis
 
 
-class Squeeze(Primitive):
-    """
-    Return the Tensor after deleting the dimension of size 1 in the specified `axis`.
-
-    Refer to :func:`mindspore.ops.squeeze` for more details.
-
-    Args:
-        axis (Union[int, tuple(int)]): Specifies the dimension indexes of shape to be removed, which will remove
-            all the dimensions of size 1 in the given axis parameter. If specified, it must be int32 or int64.
-            Default: ``()`` .
-
-    Inputs:
-        - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-
-    Outputs:
-        Tensor, the shape of tensor is :math:`(x_1, x_2, ..., x_S)`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input_x = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
-        >>> squeeze = ops.Squeeze(2)
-        >>> output = squeeze(input_x)
-        >>> print(output)
-        [[1. 1.]
-         [1. 1.]
-         [1. 1.]]
-    """
-
-    @prim_attr_register
-    def __init__(self, axis=()):
-        """Initialize Squeeze"""
-        self.init_prim_io_names(inputs=['x'], outputs=['output'])
-        validator.check_value_type('axis', axis, [int, tuple], self.name)
-        if isinstance(axis, tuple):
-            for idx, item in enumerate(axis):
-                validator.check_value_type("axis[%d]" % idx, item, [int], self.name)
-        else:
-            self.axis = (axis,)
-            self.add_prim_attr("axis", (axis,))
-
-
 class ConjugateTranspose(Primitive):
     """
     Calculate the conjugate matrix of input x which has been transposed according to input perm.
@@ -556,8 +510,8 @@ class ConjugateTranspose(Primitive):
         >>> conjugate_transpose = ops.ConjugateTranspose()
         >>> output = conjugate_transpose(x, perm)
         >>> print(output)
-            [[1.-1.j 3.-3.j]
-            [2.-2.j 4.-4.j]]
+        [[1.-1.j 3.-3.j]
+         [2.-2.j 4.-4.j]]
     """
 
     @prim_attr_register
@@ -630,65 +584,6 @@ class Unique(Primitive):
         self.init_prim_io_names(inputs=['x'], outputs=['output'])
 
 
-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.
-
-    Args:
-        return_idx (bool, optional): Whether to return the index of where the element in the original input
-            maps to the position in the output. Default: ``False`` .
-        return_counts (bool, optional): Whether to return the counts of each unique element. Default: ``False`` .
-        axis (int, optional): The dimension to apply unique. If ``None`` , the unique of the flattened input is
-            returned. If specified, it must be int32 or int64. Default: ``None`` .
-
-    Inputs:
-        - **x** (Tensor) - The input tensor.
-
-    Outputs:
-        A tensor or a tuple of tensors containing tensor objects (`output`, `idx`, `counts`).
-
-        - `output` has the same type as `x` and is used to represent the output list of unique scalar elements.
-        - If `return_idx` is True, there will be an additional returned tensor, `idx`,
-          which has the same shape as `x` and represents
-          the index of where the element in the original input maps to the position in the output.
-        - If `return_counts` is True, there will be an additional returned tensor, `counts`,
-          which represents the number of occurrences for each unique value or tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> from mindspore import dtype as mstype
-        >>> x = Tensor(np.array([1, 1, 2, 2, 3, 1, 1, 2]), mstype.int32)
-        >>> unique_consecutive = ops.UniqueConsecutive(True, True, None)
-        >>> output, idx, counts = unique_consecutive(x)
-        >>> print(output)
-        [1 2 3 1 2]
-        >>> print(idx)
-        [0 0 1 1 2 3 3 4]
-        >>> print(counts)
-        [2 2 1 2 1]
-    """
-
-    @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)
-        validator.check_value_type("axis", axis, [int, type(None)], self.name)
-        self.add_prim_attr("return_idx", return_idx)
-        self.add_prim_attr("return_counts", return_counts)
-        self.add_prim_attr("axis", axis)
-
-
 class SparseGatherV2(Primitive):
     """
     Returns a slice of input tensor based on the specified indices and axis.
@@ -1274,7 +1169,7 @@ class TupleToArray(PrimitiveWithInfer):
 
     Inputs:
         - **input_x** (tuple) - A tuple of numbers. These numbers have the same type.
-          The shape is :math:`(N,*)` where :math:`*` means any number of additional dimensions.
+          The shape is :math:`(N,)`.
 
     Outputs:
         Tensor, if the input tuple contains `N` numbers, then the shape of the output tensor is :math:`(N,)`.
@@ -1907,9 +1802,9 @@ class Unstack(Primitive):
     Refer to :func:`mindspore.ops.unstack` for more details.
 
     Args:
-        axis (int): Dimension along which to unpack. Default: ``0`` .
+        axis (int, optional): Dimension along which to unpack. Default: ``0`` .
             Negative values wrap around. The range is [-R, R).
-        num (Union[None, int]): The number of output tensors.
+        num (Union[None, int], optional): The number of output tensors.
             Automatically inferred by input_x and axis if ``None`` . Default: ``None`` .
 
     Inputs:
@@ -1943,55 +1838,6 @@ class Unstack(Primitive):
             validator.check_value_type("num", num, [int], self.name)
 
 
-class Slice(Primitive):
-    """
-    Slices a tensor in the specified shape.
-
-    Refer to :func:`mindspore.ops.slice` for more details.
-
-    Inputs:
-        - **input_x** (Tensor) - The target tensor.
-          The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **begin** (Union[tuple, list]) - The beginning of the slice. Only constant value(>=0) is allowed.
-        - **size** (Union[tuple, list]) - The size of the slice. Only constant value is allowed.
-
-    Outputs:
-        Tensor, the shape is: input `size`, the data type is the same as `input_x`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> from mindspore import Tensor
-        >>> from mindspore import ops
-        >>> import numpy as np
-        >>> data = Tensor(np.array([[[1, 1, 1], [2, 2, 2]],
-        ...                         [[3, 3, 3], [4, 4, 4]],
-        ...                         [[5, 5, 5], [6, 6, 6]]]).astype(np.int32))
-        >>> slice_op = ops.Slice()
-        >>> output = slice_op(data, (1, 0, 0), (1, 1, 3))
-        >>> print(output)
-        [[[3 3 3]]]
-        >>> output = slice_op(data, (1, 0, 0), (1, 1, 2))
-        >>> print(output)
-        [[[3 3]]]
-        >>> output = slice_op(data, (1, 0, 0), (1, 1, 1))
-        >>> print(output)
-        [[[3]]]
-        >>> output = slice_op(data, (1, 1, 0), (1, 1, 3))
-        >>> print(output)
-        [[[4 4 4]]]
-        >>> output = slice_op(data, (1, 0, 1), (1, 1, 2))
-        >>> print(output)
-        [[[3 3]]]
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize slice"""
-        self.init_prim_io_names(inputs=['x', 'begin', 'size'], outputs=['output'])
-
-
 class Coalesce(Primitive):
     """
     Returns the coalesced sparse tensor of the input.
@@ -2198,7 +2044,7 @@ class ScatterUpdate(Primitive):
         use_locking (bool): Whether to protect the assignment by a lock. Default: ``True`` .
 
     Inputs:
-        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+        - **input_x** (Union[Parameter, Tensor]) - The target tensor, with data type of Parameter or Tensor.
           The shape is 0-D or :math:`(N, *)` where :math:`*` means any number of additional dimensions.
         - **indices** (Tensor) - The index of input tensor. With int32 data type.
           If there are duplicates in indices, the order for updating is undefined.
@@ -2212,8 +2058,8 @@ class ScatterUpdate(Primitive):
         TypeError: If `use_locking` is not a bool.
         TypeError: If `indices` is not an int32.
         ValueError: If the shape of `updates` is not equal to `indices.shape + input_x.shape[1:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2267,10 +2113,10 @@ class ScatterNdUpdate(Primitive):
     the relatively highest priority data type.
 
     Args:
-        use_locking (bool): Whether to protect the assignment by a lock. Default: ``True`` .
+        use_locking (bool, optional): Whether to protect the assignment by a lock. Default: ``True`` .
 
     Inputs:
-        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+        - **input_x** (Union[Parameter, Tensor]) - The target tensor, with data type of Parameter or Tensor.
           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,
@@ -2282,8 +2128,8 @@ class ScatterNdUpdate(Primitive):
     Raises:
         TypeError: If `use_locking` is not a bool.
         TypeError: If `indices` is not an int32 or an int64.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2340,7 +2186,7 @@ class ScatterMax(_ScatterOpDynamic):
         use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
-        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+        - **input_x** (Union[Parameter, Tensor]) - The target tensor, with data type of Parameter or Tensor.
           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.
@@ -2354,8 +2200,8 @@ class ScatterMax(_ScatterOpDynamic):
         TypeError: If `use_locking` is not a bool.
         TypeError: If `indices` is not an int32 or an int64.
         ValueError: If the shape of `updates` is not equal to `indices.shape + x.shape[1:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
         RuntimeError: On the Ascend platform, the input data dimension of `input_x` , `indices`
                       and `updates` is greater than 8 dimensions.
 
@@ -2398,10 +2244,10 @@ class ScatterMin(_ScatterOpDynamic):
     when `updates` does not support conversion to the data type required by `input_x`.
 
     Args:
-        use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
+        use_locking (bool, optional): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
-        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+        - **input_x** (Union[Parameter, Tensor]) - The target tensor, with data type of Parameter or Tensor.
           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.
@@ -2415,8 +2261,8 @@ class ScatterMin(_ScatterOpDynamic):
         TypeError: If `use_locking` is not a bool.
         TypeError: If `indices` is not an int32 or an int64.
         ValueError: If the shape of `updates` is not equal to `indices.shape + input_x.shape[1:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
         RuntimeError: On the Ascend platform, the input data dimension of `input_x` , `indices`
                       and `updates` is greater than 8 dimensions.
 
@@ -2460,12 +2306,12 @@ class ScatterAdd(Primitive):
         This is an in-place update operator. Therefore, the `input_x` will be updated after the operation is completed.
 
     Args:
-        use_locking (bool): Whether to protect the assignment by a lock.
+        use_locking (bool, optional): Whether to protect the assignment by a lock.
             If ``True`` , `input_x` will be protected by the lock.
             Otherwise, the calculation result is undefined. Default: ``False`` .
 
     Inputs:
-        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+        - **input_x** (Union[Parameter, Tensor]) - The target tensor, with data type of Parameter or Tensor.
         - **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`,
@@ -2478,8 +2324,8 @@ class ScatterAdd(Primitive):
         TypeError: If `use_locking` is not a bool.
         TypeError: If `indices` is not an int32 or an int64.
         ValueError: If the shape of `updates` is not equal to `indices.shape + x.shape[1:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2580,10 +2426,10 @@ class ScatterSub(Primitive):
     the relatively highest priority data type.
 
     Args:
-        use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
+        use_locking (bool, optional): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
-        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+        - **input_x** (Union[Parameter, Tensor]) - The target tensor, with data type of Parameter or Tensor.
           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.
@@ -2597,8 +2443,8 @@ class ScatterSub(Primitive):
         TypeError: If `use_locking` is not a bool.
         TypeError: If `indices` is not an int32.
         ValueError: If the shape of `updates` is not equal to `indices_shape + x_shape[1:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2702,7 +2548,7 @@ class ScatterMul(_ScatterOpDynamic):
         use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
-        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+        - **input_x** (Union[Parameter, Tensor]) - The target tensor, with data type of Parameter or Tensor.
           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.
@@ -2716,8 +2562,8 @@ class ScatterMul(_ScatterOpDynamic):
         TypeError: If `use_locking` is not a bool.
         TypeError: If `indices` is not an int32 or an int64.
         ValueError: If the shape of `updates` is not equal to `indices.shape + input_x.shape[1:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2810,7 +2656,7 @@ class ScatterDiv(_ScatterOpDynamic):
         use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
-        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+        - **input_x** (Union[Parameter, Tensor]) - The target tensor, with data type of Parameter or Tensor.
           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.
@@ -2824,8 +2670,8 @@ class ScatterDiv(_ScatterOpDynamic):
         TypeError: If `use_locking` is not a bool.
         TypeError: If `indices` is not an int32 or an int64.
         ValueError: If the shape of `updates` is not equal to `indices.shape + input_x.shape[1:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
         RuntimeError: On the Ascend platform, the input data dimension of `input_x` , `indices`
                       and `updates` is greater than 8 dimensions.
 
@@ -2914,7 +2760,7 @@ class ScatterNdAdd(Primitive):
         use_locking (bool, optional): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
-        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+        - **input_x** (Union[Parameter, Tensor]) - The target tensor, with data type of Parameter or Tensor.
           The shape is :math:`(N, *)` where :math:`*` means any number of additional dimensions.
         - **indices** (Tensor) - The index to do add operation whose data type must be mindspore.int32.
           The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
@@ -2991,7 +2837,7 @@ class ScatterNdSub(Primitive):
         use_locking (bool, optional): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
-        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+        - **input_x** (Union[Parameter, Tensor]) - The target tensor, with data type of Parameter or Tensor.
           The shape is :math:`(N, *)` where :math:`*` means any number of additional dimensions.
         - **indices** (Tensor) - The index to do sub operation whose data type must be mindspore.int32.
           The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
@@ -3072,7 +2918,7 @@ class ScatterNdMul(_ScatterNdOp):
         use_locking (bool, optional): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
-        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+        - **input_x** (Union[Parameter, Tensor]) - The target tensor, with data type of Parameter or Tensor.
         - **indices** (Tensor) - The index to do mul operation whose data type must be int32 or int64.
           The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
         - **updates** (Tensor) - The tensor to do the mul operation with `input_x`.
@@ -3137,7 +2983,7 @@ class ScatterNdDiv(_ScatterNdOp):
         use_locking (bool, optional): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
-        - **input_x** (Parameter) - The target tensor, with data type of Parameter.
+        - **input_x** (Union[Parameter, Tensor]) - The target tensor, with data type of Parameter or Tensor.
         - **indices** (Tensor) - The index to do div operation whose data type must be int32 or int64.
           The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
         - **updates** (Tensor) - The tensor to do the div operation with `input_x`.
@@ -3191,7 +3037,7 @@ class ScatterNdDiv(_ScatterNdOp):
 
 class ScatterNdMax(_ScatterNdOp):
     r"""
-    Applies sparse maximum to individual values or slices in a tensor.
+    Computes sparse maximum to individual values or slices in a tensor.
 
     Using given values to update parameter value through the maximum 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.
@@ -3202,7 +3048,7 @@ class ScatterNdMax(_ScatterNdOp):
         use_locking (bool, optional): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
-        - **input_x** (Parameter) -The target tensor, with data type of Parameter.
+        - **input_x** (Union[Parameter, Tensor]) - The target tensor, with data type of Parameter or Tensor.
         - **indices** (Tensor) - The index to do maximum operation whose data type must be int32 or int64.
           The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
         - **updates** (Tensor) - The tensor to do the max operation with `input_x`.
@@ -3269,7 +3115,7 @@ class ScatterNdMin(_ScatterNdOp):
         use_locking (bool, optional): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Inputs:
-        - **input_x** (Parameter) -The target tensor, with data type of Parameter.
+        - **input_x** (Union[Parameter, Tensor]) - The target tensor, with data type of Parameter or Tensor.
         - **indices** (Tensor) - The index to do minimum operation whose data type must be int32 or int64.
           The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
         - **updates** (Tensor) - The tensor to do the max operation with `input_x`.
@@ -3735,117 +3581,13 @@ class BatchToSpaceNDV2(Primitive):
         self.add_prim_attr('origin_format', 'NHWC')
 
 
-class Meshgrid(PrimitiveWithInfer):
-    """
-    Generates coordinate matrices from given coordinate tensors.
-
-    Refer to :func:`mindspore.ops.meshgrid` for more details.
-
-    Args:
-        indexing (str, optional): Cartesian ``'xy'`` or
-            matrix ``'ij'`` indexing of output. In the 2-D case with
-            inputs of length `M` and `N`, the outputs are of shape :math:`(N, M)`
-            for ``'xy'`` indexing and :math:`(M, N)` for ``'ij'`` indexing. In the 3-D
-            case with inputs of length `M`, `N` and `P`, outputs are of shape
-            :math:`(N, M, P)` for ``'xy'`` indexing and :math:`(M, N, P)` for ``'ij'`` indexing.
-            Default: ``'xy'``.
-
-    Inputs:
-        - **input** (Union[tuple]) - A Tuple of N 1-D Tensor objects.
-          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`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([1, 2, 3, 4]).astype(np.int32))
-        >>> y = Tensor(np.array([5, 6, 7]).astype(np.int32))
-        >>> z = Tensor(np.array([8, 9, 0, 1, 2]).astype(np.int32))
-        >>> inputs = (x, y, z)
-        >>> meshgrid = ops.Meshgrid(indexing='xy')
-        >>> output = meshgrid(inputs)
-        >>> print(output)
-        (Tensor(shape=[3, 4, 5], dtype=Int32, value=
-         [[[1, 1, 1, 1, 1],
-           [2, 2, 2, 2, 2],
-           [3, 3, 3, 3, 3],
-           [4, 4, 4, 4, 4]],
-          [[1, 1, 1, 1, 1],
-           [2, 2, 2, 2, 2],
-           [3, 3, 3, 3, 3],
-           [4, 4, 4, 4, 4]],
-          [[1, 1, 1, 1, 1],
-           [2, 2, 2, 2, 2],
-           [3, 3, 3, 3, 3],
-           [4, 4, 4, 4, 4]]]),
-         Tensor(shape=[3, 4, 5], dtype=Int32, value=
-         [[[5, 5, 5, 5, 5],
-           [5, 5, 5, 5, 5],
-           [5, 5, 5, 5, 5],
-           [5, 5, 5, 5, 5]],
-          [[6, 6, 6, 6, 6],
-           [6, 6, 6, 6, 6],
-           [6, 6, 6, 6, 6],
-           [6, 6, 6, 6, 6]],
-          [[7, 7, 7, 7, 7],
-           [7, 7, 7, 7, 7],
-           [7, 7, 7, 7, 7],
-           [7, 7, 7, 7, 7]]]),
-         Tensor(shape=[3, 4, 5], dtype=Int32, value=
-         [[[8, 9, 0, 1, 2],
-           [8, 9, 0, 1, 2],
-           [8, 9, 0, 1, 2],
-           [8, 9, 0, 1, 2]],
-          [[8, 9, 0, 1, 2],
-           [8, 9, 0, 1, 2],
-           [8, 9, 0, 1, 2],
-           [8, 9, 0, 1, 2]],
-          [[8, 9, 0, 1, 2],
-           [8, 9, 0, 1, 2],
-           [8, 9, 0, 1, 2],
-           [8, 9, 0, 1, 2]]]))
-    """
-
-    @prim_attr_register
-    def __init__(self, indexing="xy"):
-        """Initialize Meshgrid."""
-        validator.check_value_type("indexing", indexing, (str), self.name)
-        validator.check_string(indexing.lower(), ["xy", "ij"], "indexing", self.name)
-        self.indexing = indexing
-
-    def infer_shape(self, x_shape):
-        validator.check_value_type("shape", x_shape, [tuple], 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, 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]
-        out_shape = tuple(tuple(shape_0) for _ in range(n))
-        return out_shape
-
-    def infer_dtype(self, x_type):
-        validator.check_subclass("input[0]", x_type[0], mstype.tensor_type, self.name)
-        n = len(x_type)
-        for i in range(1, n):
-            validator.check('x_type[%d]' % i, x_type[i], 'base', x_type[0], validator.EQ, self.name, TypeError)
-        return x_type
-
-
 class ReverseSequence(PrimitiveWithInfer):
     r"""
     Reverses variable length slices.
 
     Args:
         seq_dim (int): The dimension where reversal is performed. Required.
-        batch_dim (int): The input is sliced in this dimension. Default: ``0`` .
+        batch_dim (int, optional): The input is sliced in this dimension. Default: ``0`` .
 
     Inputs:
         - **x** (Tensor) - The input to reverse, supporting all number types including bool.
@@ -4096,10 +3838,11 @@ class EmbeddingLookup(Primitive):
     `offset`.
 
     Inputs:
-        - **input_params** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-          This represents a Tensor slice, instead of the entire Tensor. Currently, the dimension is restricted to be 2.
-        - **input_indices** (Tensor) - The shape of tensor is :math:`(y_1, y_2, ..., y_S)`.
-          Specifies the indices of elements of the original Tensor. Values can be out of range of `input_params`,
+        - **input_params** (Tensor) - a Tensor slice, the shape is :math:`(x_1, x_2, ..., x_R)`.
+          Currently, the dimension is restricted to be 2.
+        - **input_indices** (Tensor) - Specifies the indices of elements of the original Tensor.
+          The shape is :math:`(y_1, y_2, ..., y_S)`.
+          Values can be out of range of `input_params`,
           and the exceeding part will be filled with 0 in the output. Values do not support negative and the result
           is undefined if values are negative. The data type should be int32 or int64.
         - **offset** (int) - Specifies the offset value of this `input_params` slice. Thus the real indices
@@ -4326,7 +4069,8 @@ class TensorScatterUpdate(_TensorScatterOp):
     r"""
     Creates a new tensor by updating the positions in `input_x` indicated by
     `indices`, with values from `update`. This operation is almost equivalent to using
-    `mindspore.ops.ScatterNdUpdate` , except that the updates are applied on `input_x` instead of a zero tensor.
+    :class:`mindspore.ops.ScatterNdUpdate` , except that the updates are applied on output `Tensor`
+    instead of `input_x`.
 
     `indices` must have rank at least 2, the last axis is the depth of each index
     vectors. For each index vector, there must be a corresponding value in `update`. If
@@ -4488,12 +4232,25 @@ class TensorScatterSub(Primitive):
     r"""
     Creates a new tensor by subtracting the values from the positions in `input_x` indicated by
     `indices`, with values from `updates`. When multiple values are provided for the same
-    index, the result of the update will be to subtract these values respectively. This operation is almost
+    index, the result of the update will subtract these values respectively. This operation is almost
     equivalent to using :class:`mindspore.ops.ScatterNdSub` , except that the updates are applied on output `Tensor`
     instead of input `Parameter`.
 
-    .. math::
-        output\left [indices  \right ] = input\_x- update
+    .. code-block:: python
+
+        # Iterate through all index
+        for i in range(indices.shape[0]):
+            for j in range(indices.shape[1]):
+                ...
+                for k in range(indices.shape[-2]):  # The last dimension is coordinate dimension
+                    # Get current index combination
+                    index_tuple = (i, j, ..., k)
+                    # Get target position
+                    target_index = indices[index_tuple]
+                    # Get corresponding update value
+                    update_value = updates[index_tuple]
+                    # Perform subtraction operation
+                    output[target_index] -= update_value
 
     Refer to :func:`mindspore.ops.tensor_scatter_sub` for more details.
 
@@ -5237,7 +4994,7 @@ class Tril(Primitive):
             indicating the main diagonal.
 
     Inputs:
-        - **x** (Tensor) - The input tensor with shape :math:`(M, N, *)`
+        - **x** (Tensor) - The input tensor with shape :math:`(*, M, N)`
           where :math:`*` means any number of additional dimensions.
 
     Outputs:
@@ -5387,7 +5144,7 @@ class IndexPut(Primitive):
         >>> op = ops.IndexPut(accumulate = accumulate)
         >>> output = op(x1, x2, indices)
         >>> print(output)
-         [[4 5 3]
+        [[4 5 3]
          [4 5 6]]
     """
 
@@ -5780,7 +5537,7 @@ class AffineGrid(Primitive):
 
     Args:
         align_corners (bool, optional): Geometrically, each pixel of input is viewed as a squqre instead of dot.
-            If True, consider extremum -1 and 1 referring to the centers of the pixels rather than pixel corners.
+            If ``True``, consider extremum -1 and 1 referring to the centers of the pixels rather than pixel corners.
             The default value is ``False`` , extremum -1 and 1 refer to the corners of the pixels, so that sampling is
             irrelevant to resolution of the image. Default: ``False`` .
 
@@ -5792,7 +5549,7 @@ class AffineGrid(Primitive):
           or :math:`(N, C, D, H, W)` for 3D grid.
 
     Outputs:
-        Tensor, a tensor whose data type is same as 'theta', and the shape is :math:`(N, H, W, 2)` for 2D grid
+        Tensor, a tensor whose data type is same as `theta`, and the shape is :math:`(N, H, W, 2)` for 2D grid
         or :math:`(N, D, H, W, 3)` for 3D grid.
 
     Supported Platforms:
@@ -6001,7 +5758,7 @@ class TopK(Primitive):
           - CPU: all numeric types.
 
         - **k** (Union(Tensor, int)) - The number of top elements to be computed along the last dimension.
-          If `k` is a Tensor, the supported dtype is int32 and it should be 0-D or 1-D with shape :math:`(1, )` .
+          The supported dtype is int32 and it should be 0-D or 1-D Tensor with shape :math:`(1, )` .
 
     Outputs:
         A tuple consisting of `values` and `indexes`.