mindspore 2.3.0__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/ops/operations/manually_defined/ops_def.py

@@ -18,6 +18,7 @@ from __future__ import division
 
 import numbers
 import math
+import types
 import numpy as np
 from mindspore.ops import signature as sig
 from mindspore.ops.primitive import Primitive, prim_attr_register, prim_arg_register, PrimitiveWithInfer
@@ -937,6 +938,10 @@ class Tile(Primitive):
 
     Refer to :func:`mindspore.ops.tile` for more details.
 
+    Note:
+        On Ascend, the number of `dims` should not exceed 8, and currently does not support scenarios
+        where more than 4 dimensions are repeated simultaneously.
+
     Inputs:
         - **input** (Tensor) - The tensor whose elements need to be repeated. Set the shape of input tensor as
           :math:`(x_1, x_2, ..., x_S)` .
@@ -1025,6 +1030,10 @@ def tile(input, dims):
     output tensor has `input.shape[i] * dims[i]` elements, and the values of `input`
     are replicated `dims[i]` times along the i'th dimension.
 
+    Note:
+        On Ascend, the number of `dims` should not exceed 8, and currently does not support scenarios
+        where more than 4 dimensions are repeated simultaneously.
+
     Args:
         input (Tensor): The tensor whose elements need to be repeated. Set the shape of input tensor as
             :math:`(x_1, x_2, ..., x_S)` .
@@ -1127,16 +1136,16 @@ class Cast(Primitive):
         taken into account. As long as the real part is non-zero, it returns True; otherwise, it returns False.
 
     Inputs:
-        - **input_x** (Union[Tensor, Number]) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        - **input** (Union[Tensor, Number]) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
           The tensor to be cast.
-        - **type** (dtype.Number) - The valid data type of the output tensor. Only constant value is allowed.
+        - **dtype** (dtype.Number) - The valid data type of the output tensor. Only constant value is allowed.
 
     Outputs:
-        Tensor, the shape of tensor is the same as `input_x`, :math:`(x_1, x_2, ..., x_R)`.
+        Tensor, the shape of tensor is the same as `input`, :math:`(x_1, x_2, ..., x_R)`.
 
     Raises:
-        TypeError: If `input_x` is neither Tensor nor Number.
-        TypeError: If `type` is not a Number.
+        TypeError: If `input` is neither Tensor nor Number.
+        TypeError: If `dtype` is not a Number.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1146,10 +1155,10 @@ class Cast(Primitive):
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
         >>> input_np = np.random.randn(2, 3, 4, 5).astype(np.float32)
-        >>> input_x = Tensor(input_np)
-        >>> type_dst = mindspore.int32
+        >>> input = Tensor(input_np)
+        >>> dtype = mindspore.int32
         >>> cast = ops.Cast()
-        >>> output = cast(input_x, type_dst)
+        >>> output = cast(input, dtype)
         >>> print(output.dtype)
         Int32
         >>> print(output.shape)
@@ -1187,7 +1196,7 @@ def to_sequence(val):
     to_sequence
     """
     if isinstance(val, (tuple, list)):
-        return val
+        return tuple(val)
     return (val,)
 
 
@@ -1891,7 +1900,7 @@ def flash_attention_score(query, key, value, head_num, real_shift=None, drop_mas
     H2 -- Hidden size of key and value, which equals to N2 * D.
 
     .. warning::
-        This is an experimental API that is subject to change or deletion. Only support on Atlas training series.
+        This is an experimental API that is subject to change or deletion. Only support on Atlas A2 training series.
 
     Args:
         query (Tensor[float16, bfloat16]): The query tensor. Input tensor of shape :math:`(B, S1, H1)`,
@@ -2014,3 +2023,249 @@ def flash_attention_score(query, key, value, head_num, real_shift=None, drop_mas
                                                    inner_precise, input_layout, sparse_mode)
     return rank_op(query, key, value, real_shift, drop_mask, padding_mask, attn_mask, prefix, actual_seq_qlen,
                    actual_seq_kvlen)[3]
+
+
+class WhileLoop(Primitive):
+    """
+    Provide a useful op for reducing compilation times of while loop.
+    The execution logic of the WhileLoop operator can be roughly represented by the following code:
+
+    .. code-block:: python
+
+        def WhileLoop(cond_func, loop_func, init_val):
+            while(cond_func(init_val)):
+                init_val = loop_func(init_val)
+            return init_val
+
+    The current WhileLoop operator has the following syntactic limitations:
+
+    - Using a side-effect function as `loop_func` is currently not support,
+      such as operations that modify parameters, global variables, etc.
+    - The return value of `loop_func` being of a different type or shape
+      from the `init_val` is currently not support.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Inputs:
+        - **cond_func** (Function) - The condition function.
+        - **loop_func** (Function) - The loop function, take one argument and
+          return value has the same type with input argument.
+        - **init_val** (Union[Tensor, number, str, bool, list, tuple, dict]) - The initial value.
+
+    Outputs:
+        Union[Tensor, number, str, bool, list, tuple, dict], the final result of the while loop,
+        has same type and shape with input `init_val` .
+
+    Raises:
+        TypeError: If `cond_func` is not a function.
+        TypeError: If `loop_func` is not a function.
+        ValueError: If `loop_func` cannot take `init_val` as input or has different
+                    output type or shape with `init_val` .
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import ops
+        >>> def loop_while_fun(init_val):
+        ...     val = init_val
+        ...     val = val + 1
+        ...     return val
+        ...
+        >>> init_state = 10
+        >>> while_loop = ops.WhileLoop()
+        >>> result = while_loop(lambda x : x < 100, loop_while_fun, init_state)
+        >>> print(result)
+        100
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize WhileLoop."""
+
+    def __call__(self, cond_func, loop_func, init_val):
+        validator.check_value_type("cond_func", cond_func,
+                                   [types.FunctionType, types.MethodType], "WhileLoop")
+        validator.check_value_type("loop_func", loop_func,
+                                   [types.FunctionType, types.MethodType], "WhileLoop")
+        val = init_val
+        try:
+            while cond_func(val):
+                val = loop_func(val)
+        except Exception as e:
+            raise ValueError("Invalid loop_func, please check input arguments and \
+                             return value, error info: {}".format(e))
+        return val
+
+
+class Scan(Primitive):
+    """
+    Scan a function over an array while the processing of the current element
+    depends on the execution result of the previous element.
+    The execution logic of the Scan operator can be roughly represented by the following code:
+
+    .. code-block:: python
+
+        def Scan(loop_func, init, xs, length=None):
+            if xs is None:
+                xs = [None] * length
+            carry = init
+            ys = []
+            for x in xs:
+                carry, y = loop_func(carry, x)
+                ys.append(y)
+            return carry, ys
+
+    The current Scan operator has the following syntactic limitations:
+
+    - Using a side-effect function as `loop_func` is currently not support,
+      such as operations that modify parameters, global variables, etc.
+    - The first element of the return value of `loop_func` being of a different
+      type or shape from the `init_val` is currently not support.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Inputs:
+        - **loop_func** (Function) - The loop function.
+        - **init** (Union[Tensor, number, str, bool, list, tuple, dict]) - An initial loop carry value.
+        - **xs** (Union[tuple, list, None]) - The value over which to scan.
+        - **length** (Union[int, None], optional) - The size of xs. Default: ``None`` .
+        - **unroll** (bool, optional) - The flag for whether to perform loop unrolling in compile process.
+          Default: ``True`` .
+
+    Outputs:
+        Tuple(Union[Tensor, number, str, bool, list, tuple, dict], list). Output of scan loop,
+        a tuple with two elements, the first element has same type and shape with init argument,
+        and the second is a list containing the results of each loop.
+
+    Raises:
+        TypeError: If `loop_func` is not a function.
+        TypeError: If `xs` is not a tuple, a list or None.
+        TypeError: If `length` is not an int or None.
+        TypeError: If `unroll` is not a bool.
+        ValueError: If `loop_func` cannot take `init` and element of `xs` as inputs.
+        ValueError: If the return value of `loop_func` is not a tuple with two elements,
+                    or the first element of the tuple has different type or shape from `init` .
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import ops
+        >>> def cumsum(res, el):
+        ...     res = res + el
+        ...     return res, res
+        ...
+        >>> a = [1, 2, 3, 4]
+        >>> result_init = 0
+        >>> scan_op = ops.Scan()
+        >>> result = scan_op(cumsum, result_init, a)
+        >>> print(result == (10, [1, 3, 6, 10]))
+        True
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize Scan."""
+
+    def __call__(self, loop_func, init, xs, length=None, unroll=True):
+        validator.check_value_type("loop_func", loop_func,
+                                   [types.FunctionType, types.MethodType], "Scan")
+        validator.check_value_type("xs", xs, [list, tuple, None], "Scan")
+        if xs is None:
+            validator.check_value_type("length", length, [int], "Scan")
+            xs = [None] * length
+        carry = init
+        length = len(xs)
+        if not length:
+            return init, []
+        try:
+            carry, y = loop_func(carry, xs[0])
+            ys = [y]
+            i = 1
+            while i < length:
+                carry, y = loop_func(carry, xs[i])
+                ys.append(y)
+                i = i + 1
+        except Exception as e:
+            raise ValueError("Invalid loop_func, please check input arguments and \
+                             return value, error info: {}".format(e))
+        return carry, ys
+
+
+class ForiLoop(Primitive):
+    """
+    Provide a useful op for loop from lower to upper.
+    The execution logic of the ForiLoop operator can be roughly represented by the following code:
+
+    .. code-block:: python
+
+        def ForiLoop(lower, upper, loop_func, init_val):
+            for i in range(lower, upper):
+                init_val = loop_func(i, init_val)
+            return init_val
+
+    The current ForiLoop operator has the following syntactic limitations:
+
+    - Using a side-effect function as `loop_func` is currently not support,
+      such as operations that modify parameters, global variables, etc.
+    - The return value of `loop_func` being of a different type or shape
+      from the `init_val` is currently not support.
+    - Negative numbers or custom increments is currently not support.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Inputs:
+        - **lower** (Union[int, Tensor]) - The start index of loop.
+        - **upper** (Union[int, Tensor]) - The end index of loop.
+        - **loop_func** (Function) - The loop function, takes two arguments.
+        - **init_val** (Union[Tensor, number, str, bool, list, tuple, dict]) - The init value.
+        - **unroll** (bool, optional) - The flag for whether unroll in compile process,
+          only valid when the number of loop iterations is determined. Default: ``True`` .
+
+    Outputs:
+        Union[Tensor, number, str, bool, list, tuple, dict], the final result of the loop,
+        has same type and shape with input `init_val` .
+
+    Raises:
+        TypeError: If `lower` is not an int or a Tensor.
+        TypeError: If `upper` is not an int or a Tensor.
+        TypeError: If `loop_func` is not a function.
+        ValueError: If `loop_func` cannot take index and `init_val` as arguments or if the type
+                    of output it produces is different from the type or shape of `init_val` .
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import ops
+        >>> def cumsum(index, res):
+        ...     return index + res
+        ...
+        >>> result_init = 0
+        >>> fori_loop = ops.ForiLoop()
+        >>> result = fori_loop(0, 4, cumsum, result_init)
+        >>> print(result)
+        6
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize ForiLoop."""
+
+    def __call__(self, lower, upper, loop_func, init_val, unroll=True):
+        validator.check_value_type("lower", lower, [int, Tensor], "ForiLoop")
+        validator.check_value_type("upper", upper, [int, Tensor], "ForiLoop")
+        validator.check_value_type("loop_func", loop_func,
+                                   [types.FunctionType, types.MethodType], "ForiLoop")
+        val = init_val
+        try:
+            for i in range(lower, upper):
+                val = loop_func(i, val)
+        except Exception as e:
+            raise ValueError("Invalid loop_func, please check input arguments and \
+                             return value, error info: {}".format(e))
+        return val

mindspore/ops/operations/math_ops.py

@@ -38,9 +38,9 @@ from ..auto_generate import (Add, Addcdiv, Addcmul, ReduceMean, ReduceSum, Reduc
                              Greater, GreaterEqual, Gcd, LogicalNot, LogicalAnd, LogicalOr,
                              LogicalXor, Cos, ACos, Sin, Asin, Abs, Round, Atan, Atanh, Atan2,
                              LinSpace, MatrixDeterminant, LogMatrixDeterminant, Erfinv, Conj,
-                             Real, Complex, Angle, MatrixExp, CholeskyInverse, Trace, Cholesky,
+                             Real, Complex, Angle, MatrixExp, CholeskyInverse, Trace, Cholesky, Cross,
                              FFTWithSize, NextAfter, NanToNum, Eig, Qr, Roll, Maximum, Div, DivMod, CumProd,
-                             CumSum, Less, LessEqual, AssignAdd, IsFinite, IsClose, TanhGrad)
+                             CumSum, Less, LessEqual, AssignAdd, IsFinite, IsClose, TanhGrad, Xlogy, Trunc, Sign)
 
 
 def _infer_shape_reduce(x, axis, keep_dims, prim_name):
@@ -136,64 +136,6 @@ class _MathBinaryOp(_BinaryOp):
         real_shape = [dim if cmp_dim > 0 else cmp_dim for dim, cmp_dim in zip(shape_value, cmp_shape)]
         return tuple(real_shape)
 
-class SilentCheck(Primitive):
-    """
-    Implement SilentCheck on `pre_val`, `min_val`, `max_val`, `result` and
-    update them inplace with given parameters.
-
-    Args:
-        c_min_steps (int): an int determines...
-
-        c_thresh_l1 (float): a float determines...
-
-        c_coeff_l1 (float): a float determines...
-
-        c_thresh_l2 (float): a float determines...
-
-        c_coeff_l2 (float): a float determines...
-
-    Inputs:
-        - **val** (Tensor) - Tensor with dtype float32.
-        - **input_grad** (Parameter) - Tensor with dtype float32.
-        - **pre_val** (Parameter) - Input Parameter with dtype float32.
-        - **min_val** (Parameter) - Input Parameter with dtype float32.
-        - **max_val** (Parameter) - Input Parameter with dtype float32.
-        - **val_counter** (Parameter) - Input Parameter with dtype int32.
-
-    Outputs:
-        Tuple of 5 Tensors, the updated parameters.
-        - **input_grad** (Tensor) - Tensor with dtype float32.
-        - **pre_val** (Tensor) - Tensor with dtype float32.
-        - **min_val** (Tensor) - Tensor with dtype float32.
-        - **max_val** (Tensor) - Tensor with dtype float32.
-        - **result** (Tensor) - Tensor with dtype int32.
-
-    Raises:
-        TypeError: If `val` is not Tensor with dtype float32.
-        TypeError: If `result` is not Tensor with dtype int32.
-        TypeError: If `pre_val`, `min_val`, `max_val`, `input_grad` are not all Parameter type with dtype float32.
-        TypeError: If `c_thresh_l1` or `c_coeff_l1` is not a float number.
-        TypeError: If `c_min_steps` is not an int number.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> from mindspore.ops.operations.math_ops import SilentCheck
-        >>> silent_check = SilentCheck()
-        xxx
-    """
-
-    @prim_attr_register
-    def __init__(self, c_min_steps, c_thresh_l1, c_coeff_l1, c_thresh_l2, c_coeff_l2):
-        """Initialize SilentCheck."""
-        validator.check_value_type("c_min_steps", c_min_steps, [int], self.name)
-        validator.check_value_type("c_thresh_l1", c_thresh_l1, [float], self.name)
-        validator.check_value_type("c_coeff_l1", c_coeff_l1, [float], self.name)
-        validator.check_value_type("c_thresh_l2", c_thresh_l2, [float], self.name)
-        validator.check_value_type("c_coeff_l2", c_coeff_l2, [float], self.name)
-        self.add_prim_attr('side_effect_mem', True)
-
 
 class _BitwiseBinaryOp(_MathBinaryOp):
     """
@@ -1041,8 +983,8 @@ class Sub(_MathBinaryOp):
     Inputs:
         - **x** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
-          `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+          `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+          `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         - **y** (Union[Tensor, number.Number, bool]) - The second input, when the first input is a Tensor,
           the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool.
 
@@ -1246,7 +1188,7 @@ class Histogram(Primitive):
         - **x** (Tensor) - the input tensor, type support list: [float16, float32, int32].
 
     Outputs:
-        Tensor, 1-D Tensor with type int32.
+        1-D Tensor. If the input is int32, the output returns int32, otherwise it returns float32.
 
     Raises:
         TypeError: If `x` is not a Tensor.
@@ -1264,7 +1206,7 @@ class Histogram(Primitive):
         >>> op = ops.Histogram(bins=4, min=0.0, max=3.0)
         >>> y = op(x)
         >>> print(y)
-        [0 2 1 0]
+        [0. 2. 1. 0.]
     """
 
     @prim_attr_register
@@ -1440,8 +1382,8 @@ class DivNoNan(Primitive):
     Inputs:
         - **x1** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
-          `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+          `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+          `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         - **x2** (Union[Tensor, number.Number, bool]) - The second input is a number.Number or
           a bool when the first input is a bool or a tensor whose data type is number or bool\_.
           When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.
@@ -1803,48 +1745,6 @@ class Xdivy(Primitive):
         return None
 
 
-class Xlogy(Primitive):
-    r"""
-    Computes the first input tensor multiplied by the logarithm of second input tensor element-wise.
-    Returns zero when `x` is zero.
-
-    Refer to :func:`mindspore.ops.xlogy` for more details.
-
-    Inputs:
-        - **x** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
-          a bool or a tensor whose data type is
-          `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
-        - **y** (Union[Tensor, number.Number, bool]) - The second input is a number.Number or
-          a bool when the first input is a tensor or a tensor whose data type is number or bool\_.
-          When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.
-
-    Outputs:
-        Tensor, the shape is the same as the one after broadcasting,
-        and the data type is the one with higher precision or higher digits among the two inputs.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([-5, 0, 4]), mindspore.float32)
-        >>> y = Tensor(np.array([2, 2, 2]), mindspore.float32)
-        >>> xlogy = ops.Xlogy()
-        >>> output = xlogy(x, y)
-        >>> print(output)
-        [-3.465736   0.        2.7725887]
-    """
-    __mindspore_signature__ = (sig.sig_dtype.T, sig.sig_dtype.T)
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize Xlogy."""
-        self.init_prim_io_names(inputs=['x', 'y'], outputs=['output'])
-
-
 class _LogicBinaryOp(_BinaryOp):
     """
     Define logic binary operators.
@@ -2564,54 +2464,17 @@ class NMSWithMask(PrimitiveWithInfer):
         return bboxes_dtype, mstype.int32, mstype.bool_
 
 
-class Sign(Primitive):
-    r"""
-    Performs sign on the tensor element-wise.
-
-    .. math::
-        sign(x) = \begin{cases} -1, &if\ x < 0 \cr
-        0, &if\ x = 0 \cr
-        1, &if\ x > 0\end{cases}
-
-    Inputs:
-        - **x** (Tensor) - The input tensor of any dimension.
-
-    Outputs:
-        Tensor, has the same shape and dtype as the `x`.
-
-    Raises:
-        TypeError: If `x` is not a Tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-         >>> import mindspore
-         >>> import numpy as np
-         >>> from mindspore import Tensor, ops
-         >>> x = Tensor(np.array([[2.0, 0.0, -1.0]]), mindspore.float32)
-         >>> sign = ops.Sign()
-         >>> output = sign(x)
-         >>> print(output)
-         [[ 1.  0. -1.]]
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        pass
-
-
 class Tan(Primitive):
     r"""
-    Computes tangent of `x` element-wise.
+    Computes tangent of `input` element-wise.
 
     Refer to :func:`mindspore.ops.tan` for more details.
 
     Inputs:
-        - **x** (Tensor) - Input tensor of any dimension.
+        - **input** (Tensor) - Input tensor of any dimension.
 
     Outputs:
-        Tensor, has the same shape as `x`.
+        Tensor, has the same shape as `input`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2630,7 +2493,7 @@ class Tan(Primitive):
     @prim_attr_register
     def __init__(self):
         """Initialize Tan"""
-        self.init_prim_io_names(inputs=['x'], outputs=['y'])
+        self.init_prim_io_names(inputs=['input'], outputs=['output'])
 
 
 class SquareSumAll(Primitive):
@@ -3702,37 +3565,6 @@ class Imag(Primitive):
         self.init_prim_io_names(inputs=['input'], outputs=['output'])
 
 
-class Trunc(Primitive):
-    """
-    Returns a new tensor with the truncated integer values of the elements of input.
-
-    Refer to :func:`mindspore.ops.trunc` for more details.
-
-    Inputs:
-        - **input_x** (Tensor) - Input tensor of any dimension.
-
-    Outputs:
-        Tensor, the same shape and data type as `input_x`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([3.4742, 0.5466, -0.8008, -3.9079]), mindspore.float32)
-        >>> output = ops.Trunc()(x)
-        >>> print(output)
-        [ 3.  0. -0. -3.]
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize Trunc"""
-        self.init_prim_io_names(inputs=['input'], outputs=['output'])
-
-
 class TridiagonalMatMul(Primitive):
     """
     Return the result of a multiplication of two matrices, where the left one is a Tridiagonal Matrix.
@@ -4294,49 +4126,6 @@ class Polygamma(Primitive):
         self.init_prim_io_names(inputs=['a', 'x'], outputs=['y'])
 
 
-class Cross(Primitive):
-    """
-    Returns the cross product of vectors in dimension `dim` of x1 and x2.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Refer to :func:`mindspore.ops.cross` for more details.
-
-    Args:
-        dim (int): Spefcified dim along which to cumpute cross product with. Default: ``-65530`` .
-
-    Inputs:
-        - **x1** (Tensor) - Input Tensor.
-        - **x2** (Tensor) - Another input Tensor, must have the same shape and
-          the same type as `x1`, and the size of their `dim` dimension should be 3.
-
-    Outputs:
-        Tensor, has the same shape and type as inputs.
-
-    Supported Platforms:
-        ``Ascend`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> from mindspore import dtype as mstype
-        >>> from mindspore import ops
-        >>> cross = ops.Cross(dim = 0)
-        >>> x1 = Tensor([1, 2, 3], mstype.int8)
-        >>> x2 = Tensor([1, 2, 3], mstype.int8)
-        >>> output = cross(x1, x2)
-        >>> print(output)
-        [0 0 0]
-    """
-
-    @prim_attr_register
-    def __init__(self, dim=-65530):
-        validator.check_value_type('dim', dim, [int], self.name)
-        self.init_prim_io_names(inputs=['x1', 'x2'], outputs=['y'])
-
-
 class RaggedRange(Primitive):
     """
     Returns a `RaggedTensor` containing the specified sequences of numbers.