mindspore 1.10.0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/ops/operations/sparse_ops.py

@@ -18,10 +18,10 @@
 
 """Operators for sparse operators."""
 
-from mindspore._checkparam import Validator as validator
+from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.ops import signature as sig
-from mindspore.ops.primitive import PrimitiveWithInfer, prim_attr_register, Primitive
+from mindspore.ops.primitive import prim_attr_register, Primitive
 
 
 class SparseDenseCwiseAdd(Primitive):
@@ -57,9 +57,12 @@ class SparseDenseCwiseAdd(Primitive):
 
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore.common.tensor import Tensor
+        >>> from mindspore.common import dtype as ms
+        >>> from mindspore.ops.operations import sparse_ops as ops
         >>> x1_indices = Tensor([[0, 0], [2, 2]], dtype=ms.int64)
         >>> x1_values = Tensor([1, 2], dtype=ms.int32)
         >>> x1_shape = Tensor([3, 3], dtype=ms.int64)
@@ -109,9 +112,12 @@ class SparseDenseCwiseMul(Primitive):
         ValueError: If `x1_indices` proceed to cross the border the interview.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore.common.tensor import Tensor
+        >>> from mindspore.common import dtype as ms
+        >>> from mindspore.ops.operations import sparse_ops as ops
         >>> x1_indices = Tensor([[0, 0], [2, 2]], dtype=ms.int64)
         >>> x1_values = Tensor([1, 2], dtype=ms.int32)
         >>> x1_shape = Tensor([3, 3], dtype=ms.int64)
@@ -161,9 +167,12 @@ class SparseDenseCwiseDiv(Primitive):
         ValueError: If `x1_indices` proceed to cross the border the interview.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU``
 
     Examples:
+      >>> from mindspore.common.tensor import Tensor
+      >>> from mindspore.common import dtype as ms
+      >>> from mindspore.ops.operations import sparse_ops as ops
       >>> x1_indices = Tensor([[0, 0], [2, 2]], dtype=ms.int64)
       >>> x1_values = Tensor([4, 2], dtype=ms.int32)
       >>> x1_shape = Tensor([3, 3], dtype=ms.int64)
@@ -183,49 +192,56 @@ class SparseDenseCwiseDiv(Primitive):
 
 class SparseSlice(Primitive):
     r"""
-    Slices a SparseTensor based on the "start" and "size".
+    Slices a SparseTensor based on the `start` and `size`.
 
     Inputs:
-        - **indices** (Tensor) - A 2D Tensor of type int64. The indices of the SparseTensor.
-          Support int64, each element value should be a non-negative int number. The shape is :math:`(n, 2)`.
+        - **indices** (Tensor) - A 2D Tensor of shape :math:`(N, R)`, the indices of the SparseTensor.
+          Support int64, each element value should be a non-negative int number.
+          The shape is :math:`(N, R)`.
         - **values** (Tensor) - A 1D Tensor, represents the value corresponding to the position in the `indices`.
-          The shape should be :math:`(n,)`.
+          The shape should be :math:`(N,)`.
         - **shape** (Tensor) - A 1D Tensor of type int64 which specifies the shape of sparsetensor,
-          should have 2 elements, represent sparse tensor shape is :math:`(N, C)`.
+          represent sparse tensor shape. The shape should be :math:`(R,)`.
         - **start** (Tensor) - A 1D Tensor of type int64, represents the start of the slice.
+          The shape should be :math:`(R,)`.
         - **size** (Tensor) - A 1D Tensor of type int64, represents the size of the slice.
+          The shape should be :math:`(R,)`.
 
     Outputs:
         A `SparseTensor` objects resulting from splicing.
-        - *y_indices: A Tensor of type int64.
-        - *y_values: A Tensor. Has the same type as "values".
-        - *y_shape: A Tensor of type int64.
+
+        - \*y_indices: A Tensor of type int64.
+        - \*y_values: A Tensor. Has the same type as `values`.
+        - \*y_shape: A Tensor of type int64. Has the same size as `size`.
 
     Raises:
         TypeError: If the dtype of `indices`, `shape`, `start`, `size` are not int64.
         ValueError: If `indices` is not 2-D tensor.
         ValueError: If `values`, `start`, `shape` , `size` is not a 1-D tensor.
         ValueError: If the number of `indices` is not corresponding to the number of `values`.
-        ValueError: If the index of `indices` is out of the bounds of `shape`.
+        ValueError: If the shape of `indices[1]` is not corresponding to `shape`.
+        ValueError: If the shape of `shape` is not corresponding to `start`.
+        ValueError: If the shape of `shape` is not corresponding to `size`.
 
     Supported Platforms:
 
+
     Examples:
-        >>> indices = Tensor([[0, 1], [1, 2], [1, 3], [2, 2]], dtype=ms.int64)
-        >>> values = Tensor([1, 2, 3, 4])
-        >>> shape = Tensor([3, 4], dtype=ms.int64)
-        >>> start = Tensor([0, 1], dtype=ms.int64)
-        >>> size = Tensor([2, 3], dtype=ms.int64)
+        >>> indices = Tensor(np.array([[0, 1], [1, 2], [1, 3], [2, 2]]).astype(np.int64))
+        >>> values = Tensor(np.array([1, 2, 3, 4]).astype(np.int64))
+        >>> shape = Tensor(np.array([3, 4]).astype(np.int64))
+        >>> start = Tensor(np.array([0, 1]).astype(np.int64))
+        >>> size = Tensor(np.array([2, 3]).astype(np.int64))
         >>> sparseslice = ops.SparseSlice()
         >>> output = sparseslice(indices, values, shape, start, size)
         >>> print(output[0])
-        [[0, 0]
-         [1, 1]
-         [1, 2]]
+        [[0 0]
+         [1 1]
+         [1 2]]
         >>> print(output[1])
-        [1, 2, 3]
+        [1 2 3]
         >>> print(output[2])
-        [2, 3]
+        [2 3]
     """
 
     @prim_attr_register
@@ -271,7 +287,7 @@ class SparseSparseMaximum(Primitive):
         ValueError: If the `x1_shape` and `x2_shape` mismatch with each other.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x1_indices = Tensor([[0, 1], [1, 2]])
@@ -289,6 +305,7 @@ class SparseSparseMaximum(Primitive):
         >>> print(y_values)
         [3. 4. 2.]
     """
+
     @prim_attr_register
     def __init__(self):
         """Initialize SparseSparseMaximum."""
@@ -331,7 +348,7 @@ class SetSize(Primitive):
         >>> set_indices = Tensor(np.array([[0, 1], [1, 2]]).astype(np.int64))
         >>> set_values = Tensor(np.array([1, 2]).astype(np.int64))
         >>> set_shape = Tensor(np.array([3, 4]).astype(np.int64))
-        >>> setsize = op.SetSize()
+        >>> setsize = ops.SetSize()
         >>> out = setsize(set_indices, set_values, set_shape)
         >>> print(out)
         [1 1 0]
@@ -366,16 +383,19 @@ class SparseReorder(Primitive):
     Raises:
         TypeError: If `indices` or `shape` is not tensor or its dtype is not int64.
         TypeError: If `values` is not tensor or its dtype is incorrect.
-        ValueError: If the index exceeds the bounds.
+        ValueError: If the index exceeds the bounds. (Raise RuntimeError if on GPU Platform)
         ValueError: If the size of `indices` tensor shape is not equal to 2.
         ValueError: If the size of `values` or `shape` tensor shape is not equal to 1.
         ValueError: If `values` the first dimension length is not equal the first dimension length of 'indices'.
         ValueError: If `shape` the first dimension length is not equal the second dimension length of 'indices'.
 
     Supported Platforms:
-        ``Ascend````CPU``
+        ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore.common.dtype as ms
+        >>> from mindspore import Tensor
+        >>> import mindspore.ops.operations.sparse_ops as op
         >>> indices = Tensor([[2, 1], [0, 1]], dtype=ms.int64)
         >>> values = Tensor([1, 2], dtype=ms.int16)
         >>> shape = Tensor([3,3], dtype=ms.int64)
@@ -394,7 +414,7 @@ class SparseReorder(Primitive):
         self.init_prim_io_names(inputs=['indices', 'values', 'shape'], outputs=['y_indices', 'y_values'])
 
 
-class SparseToDense(PrimitiveWithInfer):
+class SparseToDense(Primitive):
     """
     Converts a sparse representation into a dense tensor.
 
@@ -406,7 +426,7 @@ class SparseToDense(PrimitiveWithInfer):
         - **sparse_shape** (tuple(int)) - A positive int tuple which specifies the shape of sparse tensor,
           should have 2 elements, represent sparse tensor shape is :math:`(N, C)`.
 
-    Returns:
+    Outputs:
         Tensor, converted from sparse tensor. The dtype is same as `values`, and the shape is `sparse_shape`.
 
     Raises:
@@ -434,34 +454,6 @@ class SparseToDense(PrimitiveWithInfer):
         self.init_prim_io_names(
             inputs=['indices', 'values', 'dense_shape'], outputs=['output'])
 
-    def __infer__(self, indices, values, sparse_shape):
-        validator.check_tensor_dtype_valid('indices', indices['dtype'], [
-            mstype.int32, mstype.int64], self.name)
-        validator.check_tensor_dtype_valid(
-            'values', values['dtype'], mstype.number_type + (mstype.bool_,), self.name)
-        indices_shape = indices['shape']
-        if len(indices_shape) != 2:
-            raise ValueError(f"For '{self.name}', the 'indices' must be a 2-D tensor, "
-                             f"but got 'indices' shape: {indices_shape}.")
-        values_shape = values['shape']
-        if len(values_shape) != 1 or values_shape[0] != indices_shape[0]:
-            raise ValueError(f"For '{self.name}', the 'values' must be a 1-D tensor and the first dimension length "
-                             f"must be equal to the first dimension length of 'indices', "
-                             f"but got 'indices' shape: {indices_shape}, 'values' shape: {values_shape}.")
-        sparse_shape_v = sparse_shape['value']
-        for i in sparse_shape_v:
-            if isinstance(i, bool) or not isinstance(i, int) or i <= 0:
-                raise ValueError(f"For '{self.name}', all elements in 'sparse_shape' must be "
-                                 f"positive int number, but got 'sparse_shape': {sparse_shape_v}.")
-        if len(sparse_shape_v) != indices_shape[1]:
-            raise ValueError(f"For '{self.name}', the length of 'sparse_shape' must be equal to the second dimension "
-                             f"length of 'indices', but got the second dimension length of 'indices': "
-                             f"{indices_shape[1]}, length of 'sparse_shape': {len(sparse_shape_v)}.")
-        out = {'shape': sparse_shape['value'],
-               'dtype': values['dtype'],
-               'value': None}
-        return out
-
 
 class SparseToDenseV2(Primitive):
     """
@@ -513,6 +505,7 @@ class SparseToDenseV2(Primitive):
         """Initialize SparseToDenseV2."""
         self.add_prim_attr("max_length", 1000000)
         self.validate_indices = validate_indices
+        validator.check_value_type('validate_indices', validate_indices, [bool], self.name)
         self.add_prim_attr("validate_indices", self.validate_indices)
         self.init_prim_io_names(
             inputs=['indices', 'output_shape', 'values', 'default_value'], outputs=['output'])
@@ -544,7 +537,7 @@ class SparseSoftmax(Primitive):
         ValueError: If the size of shape < 2.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> indices = Tensor([[0,0], [0,3], [1,2], [1,5], [2,0], [2,5]])
@@ -568,11 +561,11 @@ class SparseTensorDenseAdd(Primitive):
 
     Inputs:
         - **x1_indices** (Tensor) - A 2-D Tensor, represents the position of the element in the sparse tensor.
-          Support int32, int64, each element value should be a non-negative int number. The shape is :math:`(n, 2)`.
+          Support int32, int64, each element value should be a non-negative int number. The shape is :math:`(n, ndim)`.
         - **x1_values** (Tensor) - A 1-D Tensor, represents the value corresponding to the position in the `indices`.
           The shape should be :math:`(n,)`.
         - **x1_shape** (tuple(int)) - A positive int tuple which specifies the shape of sparse tensor,
-          should have 2 elements, represent sparse tensor shape is :math:`(N, C)`.
+          should have ndim elements, represent sparse tensor shape is :math:`(ndim,)`.
         - **x2** (Tensor) - A dense Tensor, the dtype is same as `values`.
 
     Outputs:
@@ -582,14 +575,14 @@ class SparseTensorDenseAdd(Primitive):
     Raises:
         TypeError: If the dtype of `x1_indices` and 'x1_shape' is neither int32 nor int64.
         ValueError: If `x1_shape`, shape of `x1_indices`, shape of `x1_values` and shape
-        of 'x2' don't meet the parameter description.
+                    of 'x2' don't meet the parameter description.
 
     Supported Platforms:
-        ``CPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as ops
+        >>> import mindspore.ops as ops
         >>> from mindspore.common import dtype as mstype
         >>> x1_indices = Tensor([[0, 0], [0, 1]], dtype=mstype.int64)
         >>> x1_values = Tensor([1, 1], dtype=mstype.float32)
@@ -645,9 +638,13 @@ class SparseTensorDenseMatmul(Primitive):
             and shape of `dense` don't meet the parameter description.
 
     Supported Platforms:
-        ``CPU``
+        ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore.ops import operations as ops
+        >>> from mindspore.common import dtype as mstype
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mindspore.int32)
         >>> values = Tensor([1, 2], dtype=mindspore.float32)
         >>> sparse_shape = (3, 4)
@@ -673,45 +670,6 @@ class SparseTensorDenseMatmul(Primitive):
         validator.check_value_type("adjoint_dt", adjoint_dt, [bool], self.name)
         self.set_const_input_indexes([2])
 
-    def __infer__(self, indices, values, sparse_shape, dense):
-        validator.check_tensor_dtype_valid('indices', indices['dtype'], [
-            mstype.int32, mstype.int64], self.name)
-        valid_types = (mstype.float16, mstype.float32,
-                       mstype.float64, mstype.int32, mstype.int64)
-        args = {'values': values['dtype'], 'dense': dense['dtype']}
-        validator.check_tensors_dtypes_same_and_valid(
-            args, valid_types, self.name)
-        indices_shape = indices['shape']
-        if len(indices_shape) != 2 or indices_shape[1] != 2:
-            raise ValueError(f"For '{self.name}', the 'indices' must be a 2-D tensor and "
-                             f"the second dimension length must be 2, but got 'indices' shape: {indices_shape}.")
-        values_shape = values['shape']
-        if len(values_shape) != 1 or values_shape[0] != indices_shape[0]:
-            raise ValueError(f"For '{self.name}', the 'values' must be a 1-D tensor and "
-                             f"the first dimension length must be equal to the first dimension length of 'indices', "
-                             f"but got 'indices' shape: {indices_shape}, 'values' shape: {values_shape}.")
-        a_shape = sparse_shape['value'][::-1] if self.adjoint_st else sparse_shape['value']
-        b_shape = dense['shape'][::-1] if self.adjoint_dt else dense['shape']
-        for i in a_shape:
-            if isinstance(i, bool) or not isinstance(i, int) or i <= 0:
-                raise ValueError(f"For '{self.name}', all elements in 'sparse_shape' must be "
-                                 f"positive int number, but got 'sparse_shape': {a_shape}.")
-        if len(a_shape) != 2 or len(b_shape) != 2:
-            raise ValueError(f"For '{self.name}', both the length of 'sparse_shape' and the tensor "
-                             f"rank of 'dense' must be equal to 2, but got the length of "
-                             f"'sparse_shape': {len(a_shape)}, "
-                             f"the tensor rank of 'dense': {len(b_shape)}.")
-        if a_shape[1] != b_shape[0]:
-            raise ValueError(f"For '{self.name}', the second dimension length of 'sparse_shape' must be equal to the "
-                             f"first dimension length of 'dense', but got "
-                             f"the tensor shape of 'sparse': {a_shape} and the tensor shape of 'dense': {b_shape}. "
-                             f"Don't meet the condition for matmul")
-        out_shape = [a_shape[0], b_shape[1]]
-        out = {'shape': tuple(out_shape),
-               'dtype': values['dtype'],
-               'value': None}
-        return out
-
 
 class CSRSparseMatrixToSparseTensor(Primitive):
     """
@@ -788,7 +746,7 @@ class DenseToCSRSparseMatrix(Primitive):
     Converts a dense matrix(maybe batched) to its CSR sparse form.
 
     .. warning::
-        This is an experimental prototype that is subject to change and/or deletion.
+        This is an experimental API that is subject to change or deletion.
 
     Inputs:
         - **dense_input** (Tensor) - A 2-D or 3-D Tensor. It represents the input dense matrix.
@@ -818,7 +776,7 @@ class DenseToCSRSparseMatrix(Primitive):
         ValueError: If shape[1] of `indices` and rank of `dense_input` is not the same.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+
 
     Examples:
         >>> x = Tensor([[[1., 0.], [0., 2.]]], dtype=mindspore.float32)
@@ -917,7 +875,7 @@ class Sspaddmm(Primitive):
     If `x1_shape` is :math:`(s0, s1)`, `x2_shpae` should be :math:`(s0, s2)`, the `x3_shape` should be :math:`(s2, s1)`.
 
     .. warning::
-        This is an experimental prototype that is subject to change and/or deletion.
+        This is an experimental API that is subject to change or deletion.
 
     .. math::
         out =\beta * x1  + \alpha * (x2 @ x3),
@@ -980,7 +938,7 @@ class Sspaddmm(Primitive):
         ValueError: If the shape of `alpha`, `beta` is not () or (1,).
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x1_indices = Tensor(np.array([[0, 1], [0, 1]]), mstype.int64)
@@ -1003,6 +961,17 @@ class Sspaddmm(Primitive):
         >>> print(out_shapes)
         [3 3]
     """
+    __mindspore_signature__ = (
+        sig.make_sig('x1_indices', dtype=sig.sig_dtype.T1),
+        sig.make_sig('x1_values', dtype=sig.sig_dtype.T),
+        sig.make_sig('x1_shape', dtype=sig.sig_dtype.T2),
+        sig.make_sig('x2_indices', dtype=sig.sig_dtype.T3),
+        sig.make_sig('x2_values', dtype=sig.sig_dtype.T),
+        sig.make_sig('x2_shape', dtype=sig.sig_dtype.T4),
+        sig.make_sig('x3_dense', dtype=sig.sig_dtype.T),
+        sig.make_sig('alpha', dtype=sig.sig_dtype.T),
+        sig.make_sig('beta', dtype=sig.sig_dtype.T)
+    )
 
     @prim_attr_register
     def __init__(self):
@@ -1041,7 +1010,7 @@ class SparseAddmm(Primitive):
         RuntimeError: If `x1_shape`, shape of `x2`, shape of `x3` don't meet the parameter description.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=ms.int32)
@@ -1114,6 +1083,7 @@ class SparseConcat(Primitive):
          [3, 0],
          [4, 1]]), Tensor(shape=[4], dtype=Int32, value= [1, 2, 3, 4]), Tensor(shape=[2], dtype=Int64, value= [6, 4]))
     """
+
     @prim_attr_register
     def __init__(self, concat_dim=0):
         """Initialize SparseConcat."""
@@ -1127,11 +1097,11 @@ class SparseSegmentSum(Primitive):
     Computes the sum along sparse segments of a tensor.
 
     Inputs:
-        - **x** (Tensor) - A tensor.
-        - **indices** (Tensor) - Indices is a 1-D tensor. Must be one of the following types: int32, int64.
-          Has same rank as segment_ids. The shape should be :math:`(N,)`.
-        - **segment_ids** (Tensor) - Segment_ids is a 1-D tensor. Must be one of the following types: int32, int64.
-          Values should be sorted and can be repeated. The shape should be :math:`(N,)`.
+        - **x** (Tensor) - A tensor of the first input of SparseSegmentSum.
+        - **indices** (Tensor) - 1-D Tensor of type int32 or int 64 with indices into `x`.
+          Has same rank as `segment_ids`. The shape should be :math:`(N,)`.
+        - **segment_ids** (Tensor) - 1-D Tensor of type int32 or int64 with indices into the output `y`. Values
+          should be sorted and can be repeated. The shape should be :math:`(N,)`.
 
     Outputs:
         A Tensor. Has the same type as `x` .
@@ -1145,10 +1115,10 @@ class SparseSegmentSum(Primitive):
         ValueError: If shape[0] of `indices` is not corresponding to shape[0] of `segment_ids`.
         ValueError: If indices in `segment_ids` are not contiguous or do not start from 0.
         ValueError: If `segment_ids` is not sorted.
-        ValueError: If `indices` is out of range of x's first shape.
+        ValueError: If `indices` is out of range of x's first dimension.
 
     Supported Platforms:
-        ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor([[0, 1, 2], [1, 2, 3], [3, 6, 7]], dtype=ms.float32)
@@ -1170,7 +1140,6 @@ class SparseSegmentSum(Primitive):
     def __init__(self):
         """Initialize SparseSegmentSum"""
         self.init_prim_io_names(inputs=['x', 'indices', 'segment_ids'], outputs=['y'])
-        self.add_prim_attr("cust_aicpu", self.name)
 
 
 class SparseSegmentSumWithNumSegments(Primitive):
@@ -1178,12 +1147,13 @@ class SparseSegmentSumWithNumSegments(Primitive):
     Computes the sum along sparse segments of a tensor, but it is allowed to miss id in segment_ids.
 
     Inputs:
-        - **x** (Tensor) - A Tensor.
-        - **indices** (Tensor) - Indices is a 1-D tensor. Must be one of the following types: int32, int64.
-          Has same rank as segment_ids. The shape should be :math:`(N,)`.
-        - **segment_ids** (Tensor) - Segment_ids is a 1-D tensor. Must be one of the following types: int32, int64.
-          Values should be sorted and can be repeated. The shape should be :math:`(N,)`.
-        - **num_segments** (Tensor) - Num_segments should equal the number of distinct segment_ids.
+        - **x** (Tensor) - A Tensor of the first input of SparseSegmentSumWithNumSegments.
+        - **indices** (Tensor) - 1-D Tensor with indices into `x`. Must be one of the following types: int32, int64.
+          Has same rank as `segment_ids`. The shape should be :math:`(N,)`.
+        - **segment_ids** (Tensor) - 1-D Tensor with indices into the output `y`. Must be one of the following types:
+          int32, int64. Values should be sorted and can be repeated. The shape should be :math:`(N,)`.
+        - **num_segments** (Tensor) - Num_segments indicates the size of the output.
+          It should be bigger than the largest id of `segment_ids`.
 
     Outputs:
         A Tensor. Has the same type as `x` .
@@ -1199,10 +1169,10 @@ class SparseSegmentSumWithNumSegments(Primitive):
         ValueError: If shape[0] of `indices` is not corresponding to shape[0] of `segment_ids`.
         ValueError: If `segment_ids` is not sorted.
         ValueError: If the last number of `segment_ids` is bigger than or equal to `num_segments`.
-        ValueError: If `indices` is out of range of x's first shape.
+        ValueError: If `indices` is out of range of x's first dimension.
 
     Supported Platforms:
-        ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor([[0, 1, 0, 0], [0, 1, 1, 0], [1, 0, 1, 0]], dtype=ms.float16)
@@ -1221,14 +1191,13 @@ class SparseSegmentSumWithNumSegments(Primitive):
         sig.make_sig('x', dtype=sig.sig_dtype.T1),
         sig.make_sig('indices', dtype=sig.sig_dtype.T),
         sig.make_sig('segment_ids', dtype=sig.sig_dtype.T),
-        sig.make_sig('num_segemnts', dtype=sig.sig_dtype.T)
+        sig.make_sig('num_segments', dtype=sig.sig_dtype.T)
     )
 
     @prim_attr_register
     def __init__(self):
         """Initialize SparseSegmentSumWithNumSegments"""
         self.init_prim_io_names(inputs=['x', 'indices', 'segment_ids', 'num_segments'], outputs=['y'])
-        self.add_prim_attr("cust_aicpu", self.name)
 
 
 class SparseSegmentSqrtN(Primitive):
@@ -1382,7 +1351,7 @@ class SparseMatrixNNZ(Primitive):
         ValueError: If shape[0] of `x_dense_shape` is not 2 or 3.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> dense_shape = Tensor([2,3], dtype=mstype.int32)
@@ -1403,6 +1372,65 @@ class SparseMatrixNNZ(Primitive):
             inputs=['x_dense_shape', 'x_batch_pointers', 'x_row_pointers', 'x_col_indices', 'x_values'], outputs=['y'])
 
 
+class SparseFillEmptyRows(Primitive):
+    r"""
+    Fill the blank lines in the input 2D SparseTensor with default values.
+
+    Inputs:
+        - **indices** (Tensor) - A 2-D Tensor, represents the position of the element in the sparse tensor.
+          Support int64, each element value should be a non-negative int number. The shape is :math:`(n, 2)`.
+        - **values** (Tensor) - A 1-D Tensor, represents the value corresponding to the position in the `indices`.
+          The shape should be :math:`(n,)`.
+        - **dense_shape** (Tensor) - A 1-D Tensor with only two elements, represents the shape of SparseTensor.
+          Support int64.
+        - **default_value** (Tensor) - A 0-D Tensor of the same type as `values`, scalar value to
+          fill the blank lines in the input 2D SparseTensor.
+
+    Outputs:
+        - **output_indices** (Tensor) - A 2-D Tensor, represents the position of the element in the sparse tensor
+          after being filled. Support int64, each element value should be a non-negative int number.
+          The shape is :math:`(m, 2)`, because of being filled, m>=n.
+        - **output_values** (Tensor) - A 1-D Tensor. It represents the value corresponding to the position
+          in the `output_indices`, the shape of which should be :math:`(m,)`, because of being filled, m>=n.
+        - **empty_row_indicator** (Tensor) - A 1-D Tensor. It indicates whether each row is empty.
+          Support bool. The shape is :math:`(dense\_shape[0],)`.
+        - **reverse_index_map** (Tensor) - A 1-D Tensor. It is the index that means the value here is original
+          rather than filled. Support bool. The shape is :math:`(n, 2)`.
+
+    Raises:
+        TypeError: If the dtype of `indices` is not int64.
+        TypeError: If the dtype of `dense_shape` is not int64.
+        TypeError: If the dtype of `values` and the dtype of `default_value` are not same.
+        ValueError: If `sparse_shape`, shape of `indices` and shape of `values` don't meet the parameter description.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> indices = Tensor([[1, 0]], dtype=mstype.int64)
+        >>> values = Tensor([4], dtype=mstype.float32)
+        >>> dense_shape = Tensor([2, 3], dtype=mstype.int64)
+        >>> default_value = Tensor(5, dtype=mstype.float32)
+        >>> sparsefillemptyrows = ops.SparseFillEmptyRows()
+        >>> out = sparsefillemptyrows(indices, values, dense_shape, default_value)
+        >>> print(out[0])
+        Tensor(shape=[2, 2], dtype=Int64, value=
+        [[0, 0],
+         [1, 0]])
+        >>> print(out[1])
+        Tensor(shape=[2], dtype=Float32, value= [ 5.00000000e+00,  4.00000000e+00])
+        >>> print(out[2])
+        Tensor(shape=[2], dtype=Bool, value= [ True, False])
+        >>> print(out[3])
+        Tensor(shape=[1], dtype=Int64, value= [1])
+    """
+    @prim_attr_register
+    def __init__(self):
+        """Initialize SparseFillEmptyRows."""
+        self.init_prim_io_names(inputs=['indices', 'values', 'dense_shape', 'default_value'],
+                                outputs=['output_indices', 'output_values', 'empty_row_indicator', 'reverse_index_map'])
+
+
 class SparseSegmentMeanWithNumSegments(Primitive):
     """
     Compute the mean along sparse segments of a tensor. It is allowed to have missing id in segment_ids.
@@ -1437,9 +1465,12 @@ class SparseSegmentMeanWithNumSegments(Primitive):
         ValueError: If `indices` is out of range of x's first dimension.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import Tensor
+        >>> import mindspore as ms
+        >>> import mindspore.ops.operations.sparse_ops as ops
         >>> x = Tensor([[0, 2, 0, 0], [0, 1, 1, 0], [2, 0, 2, 0]], dtype=ms.float16)
         >>> indices = Tensor([0, 2, 1], dtype=ms.int32)
         >>> segment_ids = Tensor([0, 0, 2], dtype=ms.int32)
@@ -1470,8 +1501,9 @@ class SparseAdd(Primitive):
         - **x2_indices** (Tensor) - represents the second COOTensor's indices.
         - **x2_values** (Tensor) - represents the second COOTensor's values.
         - **x2_shape** (Tensor) - represents the second COOTensor's dense shape.
-        - **thresh** (Tensor) - represents the magnitude threshold that determines if an output
-          value/index pair take space.
+        - **thresh** (Tensor) - A 0-D Tensor, represents the magnitude threshold that determines if an output
+          value/index pair take space. Its dtype should match that of the values if they are real.
+          If output's value is less than the `thresh`, it will vanish.
 
     Outputs:
         - **sum_indices** (Tensor) - this is the indices of the sum.
@@ -1497,7 +1529,7 @@ class SparseAdd(Primitive):
         TypeError: If (x1_values/x2_values)'s type is not matched with thresh's type.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> from mindspore import Tensor
@@ -1517,6 +1549,7 @@ class SparseAdd(Primitive):
         Tensor(shape=[4], dtype=Int32, value=[3, 1, 4, 2]),
         Tensor(shape=[2], dtype=Int64, value=[3, 4]))
     """
+
     @prim_attr_register
     def __init__(self):
         self.init_prim_io_names(
@@ -1530,7 +1563,7 @@ class SparseMatrixSoftmax(Primitive):
     Calculates the softmax of a CSRTensorMatrix.
 
     .. warning::
-        This is an experimental prototype that is subject to change and/or deletion.
+        This is an experimental API that is subject to change or deletion.
 
     Args:
         dtype (dtype.Number) - The valid data type. Only constant value is allowed.
@@ -1725,6 +1758,7 @@ class SparseMatrixTranspose(Primitive):
         >>> print(output[4])
         [99.]
     """
+
     @prim_attr_register
     def __init__(self, conjugate=False):
         """Initialize SparseMatrixTranspose"""
@@ -1776,7 +1810,7 @@ class SparseSparseMinimum(Primitive):
         ValueError: If shape[0] of `x1_shape` is not corresponding to shape[0] of `x2_shape`.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> from mindspore.ops.operations.sparse_ops import SparseSparseMinimum
@@ -1998,7 +2032,7 @@ class SparseMatrixMatMul(Primitive):
     r"""
     Performs a matrix multiplication of a sparse matrix x1 with dense matrix x2; return a dense matrix x1*x2.
     Each matrix may be transposed or adjointed (conjugated and transposed)
-    according to the Boolean parameters transpose_x1,adjoint_x1,transpose_x2 and adjoint_x2.
+    according to the Boolean parameters transpose_x1, adjoint_x1, transpose_x2 and adjoint_x2.
     At most one of transpose_x1 or adjoint_x1 may be True.
     Similarly, at most one of transpose_x2 or adjoint_x2 may be True.
 
@@ -2025,35 +2059,34 @@ class SparseMatrixMatMul(Primitive):
           nonzero values of the first `i - 1` rows in the corresponding batch.
         - **x1_col_indices** (Tensor) - A 1-D Tensor. It represents column indices of the nonzero values
           in the input CSR sparse matrix x1.
-        - **x1_values** (Tensor) - A 1-D Tensor. It represents all the nonzero values in the
-          input CSR sparse matrix x1.
-
+        - **x1_values** (Tensor) - A 1-D Tensor. It represents all the nonzero values
+          in the input CSR sparse matrix x1. Support float32, float64, complex64, complex128.
         - **x2_dense** (Tensor) - A 2-D or 3-D Tensor, represents the input dense matrix x2.
-          Support float32, float64, complex64, complex128.
+          Its dtype is the same as `x1_values`.
 
     Outputs:
-        **y_dense** (Tensor) - A 2-D or 3-D Tensor, represents the output dense matrix y.
-          Support float32, float64, complex64, complex128.
+        Tensor, which represents the output dense matrix y.
+        Its dtype is the same as `x1_values`.
 
     Raises:
-        TypeError: If any dtype of `x1_dense_shape`, `x1_batch_pointers`, `x1_row_pointers`, `x1_col_indices`,
-        `x1_values` or `x2_dense` doesn't meet the parameter description.
-        ValueError: If shape[0] of `x1_dense_shape` or the dimension of `x2_dense' is not 2 or 3.
-        ValueError: If shape[0]-1 of x1_batch_pointers and shape[0] of x2_dense are not the same.
+        TypeError: If the dtype of `x1_dense_shape`, `x1_batch_pointers`, `x1_row_pointers` or `x1_col_indices`
+                   is not int32 or int64, or the dtypes of above inputs are not the same.
+        TypeError: If the dtype of `x1_values`, `x2_dense` is not supported.
+        ValueError: If shape[0] of `x1_dense_shape` or the dimension of `x2_dense` is not 2 or 3.
+        ValueError: If shape[0]-1 of `x1_batch_pointers` and shape[0] of `x2_dense` are not the same.
 
     Supported Platforms:
-
+        ``CPU``
 
     Examples:
-        >>> from mindspore.ops.operations.sparse_ops import SparseMatrixMatMul
-        >>> x1_dense_shape = Tensor([4, 5], dtype=mindspore.int32)
-        >>> x1_batch_pointers = Tensor([0, 4], dtype=mindspore.int32)
-        >>> x1_row_pointers = Tensor([0, 1, 1, 3, 4], dtype=mindspore.int32)
-        >>> x1_col_indices = Tensor([0, 3, 4, 0], dtype=mindspore.int32)
-        >>> x1_values = Tensor([1.0, 5.0, -1.0, -2.0], dtype=mindspore.float32)
+        >>> x1_dense_shape = Tensor([4, 5], dtype=ms.int32)
+        >>> x1_batch_pointers = Tensor([0, 4], dtype=ms.int32)
+        >>> x1_row_pointers = Tensor([0, 1, 1, 3, 4], dtype=ms.int32)
+        >>> x1_col_indices = Tensor([0, 3, 4, 0], dtype=ms.int32)
+        >>> x1_values = Tensor([1.0, 5.0, -1.0, -2.0], dtype=ms.float32)
         >>> x2_dense = Tensor([[2.0, 0.8, 1.0],[ 2.9, 3.2, 0.0],[7.0, 4.6, 0.2],[3.5, 4.9, 1.4],[4.0, 3.7, 6.9]],
-        ... dtype=mindspore.float32)
-        >>> sparse_matrix_mat_mul = SparseMatrixMatMul()
+        ... dtype=ms.float32)
+        >>> sparse_matrix_mat_mul = ops.SparseMatrixMatMul()
         >>> out = sparse_matrix_mat_mul(x1_dense_shape, x1_batch_pointers, x1_row_pointers, x1_col_indices,
         ... x1_values, x2_dense)
         >>> print(out)
@@ -2149,6 +2182,7 @@ class SparseMatrixAdd(Primitive):
          Tensor(shape=[2], dtype=Int32, values = [0, 1]),
          Tensor(shape=[2], dtype=Float32, values = [2.0, 4.0]))
     """
+
     @prim_attr_register
     def __init__(self):
         '''Initialize for SparseMatrixAdd'''
@@ -2194,6 +2228,7 @@ class SparseSplit(Primitive):
     Supported Platforms:
 
     """
+
     @prim_attr_register
     def __init__(self, num_split=1):
         """Initialize SparseSplit."""
@@ -2307,7 +2342,7 @@ class SparseReshape(Primitive):
         RuntimeError: If inferred-dim(-1) in `new_shape` cannot be correctly inferred.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> indices = Tensor([[0, 0, 0],
@@ -2329,6 +2364,7 @@ class SparseReshape(Primitive):
         >>> print(y_shape)
         [9 4]
     """
+
     @prim_attr_register
     def __init__(self):
         """Initialize SparseReshape."""
@@ -2371,8 +2407,8 @@ class SparseCountSparseOutput(Primitive):
         ValueError: If number of values does not match first dimension of indices
         ValueError: If number of dense_shape dimensions does not match second dimension of indices
         ValueError: If num dim of dense_shape is < 1
-        RunTimeError: If number of weights is not equal to number of values
-        RunTimeError: If indexes are not in bounds of the dense shape
+        RuntimeError: If number of weights is not equal to number of values
+        RuntimeError: If indexes are not in bounds of the dense shape
 
     Examples:
         >>> from mindspore.ops.operations.sparse_ops import SparseCountSparseOutput
@@ -2393,6 +2429,7 @@ class SparseCountSparseOutput(Primitive):
         ``CPU``
 
     """
+
     @prim_attr_register
     def __init__(self, binary_output=False, minlength=-1, maxlength=-1):
         self.init_prim_io_names(
@@ -2401,3 +2438,311 @@ class SparseCountSparseOutput(Primitive):
         validator.check_value_type("binary_output", binary_output, [bool], self.name)
         validator.check_value_type("minlength", minlength, [int], self.name)
         validator.check_value_type("maxlength", maxlength, [int], self.name)
+
+
+class DenseToSparseSetOperation(Primitive):
+    """
+    Applies set operation along last dimension of `x1` and `x2`.
+    Input `x2` is a SparseTensor represented by `x2_indices`, `x2_values`, and `x2_shape`.
+    For `x2` ranked `n`, 1st `n-1` dimensions must be the same as `x1`. Dimension `n` contains values in a set,
+    duplicates are allowed but ignored.
+
+    Args:
+        set_operation (str): The type of set operation, supports four kinds of inputs, case insensitive. Default: "".
+            "a-b": Get the difference set of x1 to x2.
+            "b-a": Get the difference set of x2 to x1.
+            "intersection": Get the intersection set of x2 to x1.
+            "union": Get the union set of x2 to x1.
+        validate_indices (bool): Optional attributes for DenseToSparseSetOperation.  Default: True.
+
+    Inputs:
+        - **x1** (Tensor) - The input tensor `x1` with rank `n`. 1st `n-1` dimensions must be the same as `x2`.
+          Dimension `n` contains values in a set, duplicates are allowed but ignored. Must be one of the
+          following types: int8, int16, int32, int64, uint8, uint16.
+        - **x2_indices** (Tensor) - A 2-D Tensor, type int64, indices of a SparseTensor.
+        - **x2_values** (Tensor) - A 1-D Tensor, must have the same type as x1, values of a SparseTensor. Size
+          must be the same as `x2_indices`
+        - **x2_shape** (Tensor) - A 1-D Tensor, type int64, shape of a SparseTensor, must have the same size as
+          the second dimensions of `x2_indices`
+
+    Outputs:
+        y_indices: A Tensor of type int64.
+        y_values: A Tensor. Has the same type as x1.
+        y_shape: A Tensor of type int64 .
+
+    Raises:
+        TypeError: If any input is not Tensor.
+        TypeError:If the dtype of `x2_values` is not the same as 'x1'.
+        TypeError:If the dtype of `x2_indices` or `x2_shape` is not int64.
+        ValueError: If the group shape of `x1` or `x2` mismatch with each other.
+        ValueError: If the rank of `x1` is less than 2.
+        ValueError: If the rank of `x2_indices` is not equal 2.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> from mindspore.ops.operations.sparse_ops import DenseToSparseSetOperation
+        >>> x1 = Tensor([[1, 2], [3, 0], [1, 5]], dtype=ms.int64)
+        >>> x2_indices = Tensor([[0, 1], [0, 2], [1, 2]], dtype=ms.int64)
+        >>> x2_values = Tensor([5, 1, 7],dtype=ms.int64)
+        >>> x2_shape = Tensor([3, 3], dtype=ms.int64)
+        >>> dense_to_sparse_set_operation = DenseToSparseSetOperation(set_operation='intersection')
+        >>> out = dense_to_sparse_set_operation(x1, x2_indices, x2_values, x2_shape)
+        >>> print(out)
+        (Tensor(shape=[1, 2], dtype=Int64, value=
+        [[0, 0]]), Tensor(shape=[1], dtype=Int64, value= [1]), Tensor(shape=[2], dtype=Int64, value= [3, 1]))
+    """
+
+    @prim_attr_register
+    def __init__(self, set_operation="", validate_indices=True):
+        """Initialize DenseToSparseSetOperation."""
+        self.init_prim_io_names(inputs=['x1', 'x2_indices', 'x2_values', 'x2_shape'],
+                                outputs=['y_indices', 'y_values', 'y_shape'])
+        self.set_operation = set_operation
+        self.validate_indices = validate_indices
+        self.add_prim_attr('set_operation', self.set_operation)
+        self.add_prim_attr('validate_indices', self.validate_indices)
+
+        validator.check_value_type("set_operation", set_operation, [str], self.name)
+        validator.check_value_type("validate_indices", validate_indices, [bool], self.name)
+
+
+class RaggedTensorToTensor(Primitive):
+    r"""
+    Create a dense tensor from a ragged tensor, possibly altering its shape.
+
+    Args:
+        row_partition_types(list(str)): A list of `strings`. The types of the row partition tensors.
+            At present, these can be:
+            "ROW_SPLITS": the row_splits tensor from the ragged tensor.
+            "VALUE_ROWIDS": the value_rowids tensor from the ragged tensor.
+            "FIRST_DIM_SIZE": if value_rowids is used for the first dimension, then it is preceded by "FIRST_DIM_SIZE".
+
+    Inputs:
+        - **shape** (Tensor) - A 1-D `Tensor`. Must be one of the following types: `int64`, `int32`.
+          The desired shape of the output tensor.
+        - **values** (Tensor) - A 1-D or higher `Tensor` representing the values of the ragged tensor.
+        - **default_value** (Tensor) - A `Tensor` representing the default value of the ragged tensor.
+          Must have the same type as `values` and less dimension than `values`.
+        - **row_partition_tensors** (list(Tensor)) - A list of at least 1 `Tensor` objects with the same
+          type in: `int64`, `int32`. The row partition tensor is 0-D, 1-D, 1-D, when the row partition type is
+          "FIRST_DIM_SIZE", "VALUE_ROWIDS", "ROW_SPLITS" respectively.
+
+    Outputs:
+        A `Tensor`. Has the same type as `values` and the shape is `shape`.
+
+    Raises:
+        TypeError: If the type of `shape`, `values` or `default_value` is not Tensor.
+        ValueError: If the dimension of `shape` or `values` is not 1.
+        ValueError: If the dimension of `default_value` is more than `values`.
+        ValueError: If the order or value of `row_partition_types` is not support.
+        RuntimeError: If the value of `row_partition_tensors` is not in ascending order
+            when the `row_partition_types` is "ROW_SPLITS".
+        RuntimeError: If value rowid is not less than first dim size
+            when the `row_partition_types` is "FIRST_DIM_SIZE", "VALUE_ROWIDS".
+        ValueError: If row partition size plus `values` rank is not equal to `shape` rank.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> from mindspore.ops.operations.sparse_ops import RaggedTensorToTensor
+        >>> shape = Tensor([4, 4], mstype.int32)
+        >>> values = Tensor([1, 2, 3, 4, 5, 6, 7, 8, 9], mstype.int64)
+        >>> default_value = Tensor(0, dtype=mstype.int64)
+        >>> row_partition_tensors_list = []
+        >>> row_partition_tensors = Tensor([0, 3, 3, 7, 9], mstype.int32)
+        >>> row_partition_tensors_list.append(row_partition_tensors)
+        >>> row_partition_types = ["ROW_SPLITS"]
+        >>> ragged_tensor_to_tensor = RaggedTensorToTensor(row_partition_types)
+        >>> out = ragged_tensor_to_tensor(shape, values, default_value, row_partition_tensors_list)
+        >>> print(out)
+        [[1 2 3 0]
+         [0 0 0 0]
+         [4 5 6 7]
+         [8 9 0 0]]
+    """
+
+    @prim_attr_register
+    def __init__(self, row_partition_types):
+        """Initialize RaggedTensorToTensor"""
+        self.init_prim_io_names(inputs=['shape', 'values', 'default_value', 'row_partition_tensors'],
+                                outputs=['result'])
+        validator.check_value_type("row_partition_types", row_partition_types, [list], self.name)
+
+        if not row_partition_types:
+            raise ValueError(f"For {self.name}, row_partition_types cannot be empty.")
+
+        for i, item in enumerate(row_partition_types):
+            validator.check_value_type(f"row_partition_types[{i}]", item, [str], self.name)
+
+        valid_values = ("ROW_SPLITS", "FIRST_DIM_SIZE", "VALUE_ROWIDS")
+        if not set(row_partition_types).issubset(valid_values):
+            diff = tuple(set(row_partition_types).difference(valid_values))
+            raise ValueError(
+                f"For {self.name}, row_partition_types only support {valid_values}, "
+                f"but got {diff if len(diff) > 1 else repr(diff[0])}.")
+
+        first_element = valid_values[:2]
+        if row_partition_types[0] not in first_element:
+            raise ValueError(
+                f"For {self.name}, the first element of row_partition_types must be in {first_element}, "
+                f"but got '{row_partition_types[0]}'.")
+
+        if row_partition_types[0] == "FIRST_DIM_SIZE":
+            if set(row_partition_types[1:]) != {"VALUE_ROWIDS"}:
+                raise ValueError(
+                    f"For {self.name}, 'VALUE_ROWIDS' must be preceded by 'FIRST_DIM_SIZE' in row_partition_types.")
+        else:
+            if set(row_partition_types) != {"ROW_SPLITS"}:
+                raise ValueError(
+                    f"For {self.name}, the each element of row_partition_types must be 'ROW_SPLITS' "
+                    f"when row_splits tensor.")
+
+
+class SparseCross(Primitive):
+    """
+    Generates sparse cross from a list of sparse and dense tensors.
+
+    Args:
+        hashed_output (bool): If true, returns the hash of the cross instead of the string. This will allow us
+                              avoiding string manipulations.
+        num_buckets (int): An int that is >= 0. It is used if "hashed_output" is true.output = hashed_value%num_buckets
+                           if num_buckets > 0 else "hashed_value".
+        hash_key (int): Specify the hash_key that will be used by the "FingerprintCat64" function to combine the
+                        crosses fingerprints.
+        out_type (mindspore.dtype): The output data type. Defaults to "int64".
+        internal_type (mindspore.dtype): An type int64.
+
+    Inputs:
+        - **indices** (list(Tensor)) - A list of Tensor objects with type int64. 2-D.
+          Indices of each input SparseTensor.
+        - **values** (list(Tensor)) - A list of Tensor objects with types from: int64.
+          1-D. values of each SparseTensor.
+        - **shapes** (list(Tensor)) - A list with the same length as indices of Tensor objects with type int64.
+          1-D. Shapes of each SparseTensor.
+        - **dense_inputs** (list(Tensor)) - A list of Tensor objects with types from: int64.
+          2-D. Columns represented by dense Tensor.
+
+    Outputs:
+        - **output_indices** (Tensor) - A Tensor of type int64. 2-D. Indices of the concatenated SparseTensor.
+        - **output_values** (Tensor) - A Tensor of type "out_type". 1-D.
+          Non-empty values of the concatenated or hashed SparseTensor.
+        - **output_shape** (Tensor) - A Tensor of type int64. 1-D. Shape of the concatenated SparseTensor.
+
+    Raises:
+        TypeError: The indices shape rank is not equal to the shape rank.
+        TypeError: The indices element number is not equal to the value element number.
+        TypeError: The indices shape rank should be 2.
+        TypeError: The denses shape rank should be 2.
+        TypeError: The shapes rank should be 2.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> from mindspore.ops.operations.sparse_ops import SparseCross
+        >>> indice1 = Tensor([[0,0],[1,0],[1,1]], dtype=mstype.int64)
+        >>> value1 = Tensor([1, 2, 3], dtype=mstype.int64)
+        >>> shape1 = Tensor([2, 2], dtype=mstype.int64)
+        >>> dense1 = Tensor([[1],[2]], dtype=mstype.int64)
+        >>> indice2 = Tensor([[0,0],[1,0],[1,1]], dtype=mstype.int64)
+        >>> value2 = Tensor([1, 2, 3], dtype=mstype.int64)
+        >>> shape2 = Tensor([2, 2], dtype=mstype.int64)
+        >>> dense2 = Tensor([[1],[2]], dtype=mstype.int64)
+        >>> indices = [indice1, indice2]
+        >>> values = [value1, value2]
+        >>> shapes = [shape1, shape2]
+        >>> dense_inputs = [dense1, dense2]
+        >>> hashed_output=True
+        >>> hash_key= 2
+        >>> out_type= mstype.int64
+        >>> internal_type = mstype.int64
+        >>> num_buckets=0
+        >>> sparse_cross = SparseCross(hashed_output, hash_key, out_type, internal_type, num_buckets)
+        >>> out = sparse_cross(indices, values, shapes, dense_inputs)
+        >>> print(out)
+        (Tensor(shape=[5, 2], dtype=Int64, value=
+        [[0, 0],
+        [1, 0],
+        [1, 1],
+        [1, 2],
+        [1, 3]]), Tensor(shape=[5], dtype=Int64, value= [1350190460805457680, 6319552725219729347,
+        4652439303631496997, 7670687697825594049,  174086171018132662]), Tensor(shape=[2], dtype=Int64, value= [2, 4]))
+    """
+
+    @prim_attr_register
+    def __init__(self, hashed_output, hash_key, out_type, internal_type, num_buckets=0):
+        """Initialize SparseCross."""
+        self.init_prim_io_names(inputs=["indices", "values", "shapes", "dense_inputs"],
+                                outputs=["output_indices", "output_values", "output_shape"])
+        validator.check_value_type("hashed_output", hashed_output, [bool], self.name)
+        validator.check_value_type("hash_key", hash_key, [int], self.name)
+        validator.check_value_type("out_type", out_type, [mstype.Type], self.name)
+        validator.check_value_type("internal_type", internal_type, [mstype.Type], self.name)
+        validator.check_value_type("num_buckets", num_buckets, [int], self.name)
+
+
+class RaggedTensorToSparse(Primitive):
+    r"""
+    Converts a RaggedTensor into a SparseTensor with the same values.
+
+    Args:
+        Tsplits(mindspore.dtype): A required attribute, the type of the `rt_nested_splits`. Default: `int64`.
+
+    Inputs:
+        - **rt_nested_splits** (list(Tensor)) - A list of at least 1 `Tensor` objects with the same
+          type in: `int64`, `int32`. The row_splits for the RaggedTensor.
+          Ragged splits is in ascending order, first value of splits must be 0 and final value of splits
+          must equal with the length of `rt_dense_values`.
+        - **rt_dense_values** (Tensor) - A `Tensor`. The flat_values for the RaggedTensor. The rank of values
+          must more than 0.
+
+    Outputs:
+        - **sparse_indices** (Tensor) - A `Tensor` of type int64. Contains the indices of the output
+          sparse tensor.
+        - **sparse_values** (Tensor) - A `Tensor`. Has the same type as rt_dense_values.
+          Contains the values of the output sparse tensor.
+        - **sparse_dense_shape** (Tensor) - A `Tensor` of type int64. Contains the dense shape of the
+          output sparse tensor.
+
+    Raises:
+        TypeError: If the type of `Tsplits`, `rt_nested_splits` or `rt_dense_values` is not support.
+        RuntimeError: If the order of `rt_nested_splits` is not support.
+        RuntimeError: If the first value of `rt_nested_splits` is not 0.
+        RuntimeError: If the final value of `rt_nested_splits` is not equal with the length of
+            `rt_dense_values`.
+        ValueError: If the rank of `rt_dense_values` is not more than 0.
+
+    Supported Platforms:
+
+
+    Examples:
+        >>> from mindspore.ops.operations.sparse_ops import RaggedTensorToSparse
+        >>> rt_nested_splits = Tensor([0, 3, 3, 5, 6], mstype.int64)
+        >>> rt_dense_values = Tensor([1, 2, 3, 4, 5, 6], mstype.int32)
+        >>> rt_nested_splits_list = []
+        >>> rt_nested_splits_list.append(rt_nested_splits)
+        >>> Tsplits = mstype.int64
+        >>> ragged_tensor_to_sparse = RaggedTensorToSparse(Tsplits)
+        >>> out = ragged_tensor_to_sparse(rt_nested_splits_list, rt_dense_values)
+        >>> print(out)
+        (Tensor(shape=[6, 2], dtype=Int64, value=
+        [[0, 0],
+         [0, 1],
+         [0, 2],
+         [2, 0],
+         [2, 1],
+         [3, 0]]),
+         Tensor(shape=[6], dtype=Int32, value= [1, 2, 3, 4, 5, 6]),
+         Tensor(shape=[2], dtype=Int64, value= [4, 3]))
+    """
+    @prim_attr_register
+    def __init__(self, Tsplits):
+        """Initialize RaggedTensorToSparse."""
+        self.init_prim_io_names(inputs=['rt_nested_splits', 'rt_dense_values'],
+                                outputs=['sparse_indices', 'sparse_values', 'sparse_dense_shape'])
+        validator.check_value_type("Tsplits", Tsplits, [mstype.Type], self.name)
+        valid_values = {mstype.int64, mstype.int32}
+        validator.check_type_name("Tsplits", Tsplits, valid_values, self.name)