mindspore 2.4.10__cp311-none-any.whl → 2.5.0__cp311-none-any.whl

mindspore/ops/operations/array_ops.py

@@ -35,14 +35,15 @@ from mindspore.common import Tensor, CSRTensor, COOTensor
 from mindspore._c_expression import Tensor 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, 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)
+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)
@@ -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.
@@ -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``
@@ -2270,7 +2116,7 @@ class ScatterNdUpdate(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 :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.
 
@@ -2401,7 +2247,7 @@ class ScatterMin(_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 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.
 
@@ -2465,7 +2311,7 @@ class ScatterAdd(Primitive):
             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``
@@ -2583,7 +2429,7 @@ class ScatterSub(Primitive):
         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 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`.
@@ -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,110 +3581,6 @@ 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.
@@ -4326,7 +4068,7 @@ 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 `input_x` instead of a zero tensor.
 
     `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
@@ -5237,7 +4979,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 +5129,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]]
     """