mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/function/sparse_unary_func.py

@@ -21,11 +21,11 @@ from mindspore.ops.function import math_func, nn_func
 
 
 def csr_cos(x: CSRTensor) -> CSRTensor:
-    """
+    r"""
     Computes cosine of input element-wise.
 
     .. math::
-        out_i = cos(x_i)
+        out_i = \cos(x_i)
 
     .. warning::
         Currently support data types float16 and float32. If use Float64, there may be a problem of missing precision.
@@ -45,6 +45,8 @@ def csr_cos(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -60,11 +62,11 @@ def csr_cos(x: CSRTensor) -> CSRTensor:
 
 
 def coo_cos(x: COOTensor) -> COOTensor:
-    """
+    r"""
     Computes cosine of input element-wise.
 
     .. math::
-        out_i = cos(x_i)
+        out_i = \cos(x_i)
 
     .. warning::
         If use Float64, there may be a problem of missing precision.
@@ -84,6 +86,8 @@ def coo_cos(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -103,7 +107,7 @@ def csr_tan(x: CSRTensor) -> CSRTensor:
 
     .. math::
 
-        out_i = tan(x_i)
+        out_i = \tan(x_i)
 
     Args:
         x (CSRTensor): The input CSRTensor.
@@ -118,6 +122,8 @@ def csr_tan(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -138,7 +144,7 @@ def coo_tan(x: COOTensor) -> COOTensor:
 
     .. math::
 
-        out_i = tan(x_i)
+        out_i = \tan(x_i)
 
     Args:
         x (COOTensor): The input COOTensor.
@@ -153,6 +159,8 @@ def coo_tan(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -187,6 +195,8 @@ def csr_exp(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -222,6 +232,8 @@ def coo_exp(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -256,6 +268,8 @@ def csr_inv(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -291,6 +305,8 @@ def coo_inv(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -305,7 +321,7 @@ def coo_inv(x: COOTensor) -> COOTensor:
 
 
 def csr_relu(x: CSRTensor) -> CSRTensor:
-    """
+    r"""
     Computes ReLU (Rectified Linear Unit activation function) of input csr_tensors element-wise.
 
     It returns max(x, 0) element-wise. Specially, the neurons with the negative output
@@ -313,7 +329,7 @@ def csr_relu(x: CSRTensor) -> CSRTensor:
 
     .. math::
 
-        ReLU(x) = (x)^+ = max(0, x)
+        ReLU(x) = (x)^+ = \max(0, x)
 
     Note:
         In general, this operator is more commonly used. The difference from `ReLuV2` is that the `ReLuV2` will
@@ -333,6 +349,8 @@ def csr_relu(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -356,7 +374,7 @@ def coo_relu(x: COOTensor) -> COOTensor:
 
     .. math::
 
-        ReLU(x) = (x)^+ = max(0, x)
+        ReLU(x) = (x)^+ = \max(0, x)
 
     Note:
         In general, this operator is more commonly used. The difference from `ReLuV2` is that the `ReLuV2` will
@@ -365,7 +383,7 @@ def coo_relu(x: COOTensor) -> COOTensor:
     Args:
         x (COOTensor): Input COOTensor with shape :math:`(N, *)`, where :math:`*`
             means any number of additional dimensions. Its dtype is
-            `number <https://www.mindspore.cn/docs/en/r2.0/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
 
     Returns:
         COOTensor, has the same shape and dtype as the `x`.
@@ -378,6 +396,8 @@ def coo_relu(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -413,6 +433,8 @@ def csr_expm1(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -449,6 +471,8 @@ def coo_expm1(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -469,7 +493,7 @@ def csr_isfinite(x: CSRTensor) -> CSRTensor:
     .. math::
 
         out_i = \begin{cases}
-          & \text{ if } x_{i} = \text{Finite},\ \ True\  \\
+          & \text{ if } x_{i} = \text{Finite},\ \ True \\
           & \text{ if } x_{i} \ne \text{Finite},\ \ False
         \end{cases}
 
@@ -486,6 +510,8 @@ def csr_isfinite(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -524,6 +550,8 @@ def coo_isfinite(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -538,12 +566,12 @@ def coo_isfinite(x: COOTensor) -> COOTensor:
 
 
 def csr_asin(x: CSRTensor) -> CSRTensor:
-    """
+    r"""
     Computes arcsine of input csr_tensors element-wise.
 
     .. math::
 
-        out_i = sin^{-1}(x_i)
+        out_i = \sin^{-1}(x_i)
 
     Args:
         x (CSRTensor): Input CSRTensor. The data types should be one of the following types:
@@ -560,6 +588,8 @@ def csr_asin(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -575,16 +605,16 @@ def csr_asin(x: CSRTensor) -> CSRTensor:
 
 
 def coo_asin(x: COOTensor) -> COOTensor:
-    """
+    r"""
     Computes arcsine of input coo_tensors element-wise.
 
     .. math::
 
-        out_i = sin^{-1}(x_i)
+        out_i = \sin^{-1}(x_i)
 
     Args:
         x (COOTensor): Input COOTensor. The shape of COOTensor is :math:`(N,*)` ,
-            where :math:`*` means,any number of additional dimensions.
+            where :math:`*` means any number of additional dimensions.
             The data type should be one of the following types: float16, float32, float64, complex64, complex128.
 
     Returns:
@@ -598,6 +628,8 @@ def coo_asin(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -632,6 +664,8 @@ def csr_sqrt(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -667,6 +701,8 @@ def coo_sqrt(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -681,11 +717,11 @@ def coo_sqrt(x: COOTensor) -> COOTensor:
 
 
 def csr_log(x: CSRTensor) -> CSRTensor:
-    """
+    r"""
     Returns the natural logarithm of a CSRTensor element-wise.
 
     .. math::
-        y_i = log_e(x_i)
+        y_i = \log_e(x_i)
 
     .. warning::
         If the input value of operator Log is within the range (0, 0.01] or [0.95, 1.05], the output accuracy may
@@ -706,6 +742,8 @@ def csr_log(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -721,11 +759,11 @@ def csr_log(x: CSRTensor) -> CSRTensor:
 
 
 def coo_log(x: COOTensor) -> COOTensor:
-    """
+    r"""
     Returns the natural logarithm of a COOTensor element-wise.
 
     .. math::
-        y_i = log_e(x_i)
+        y_i = \log_e(x_i)
 
     .. warning::
         If the input value of operator Log is within the range (0, 0.01] or [0.95, 1.05], the output accuracy may
@@ -746,6 +784,8 @@ def coo_log(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -785,6 +825,8 @@ def csr_isnan(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -825,6 +867,8 @@ def coo_isnan(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -839,12 +883,12 @@ def coo_isnan(x: COOTensor) -> COOTensor:
 
 
 def csr_acos(x: CSRTensor) -> CSRTensor:
-    """
+    r"""
     Computes arccosine of input csr_tensors element-wise.
 
     .. math::
 
-        out_i = cos^{-1}(x_i)
+        out_i = \cos^{-1}(x_i)
 
     Args:
         x (CSRTensor): Input CSRTensor.
@@ -861,6 +905,8 @@ def csr_acos(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -876,12 +922,12 @@ def csr_acos(x: CSRTensor) -> CSRTensor:
 
 
 def coo_acos(x: COOTensor) -> COOTensor:
-    """
+    r"""
     Computes arccosine of input coo_tensors element-wise.
 
     .. math::
 
-        out_i = cos^{-1}(x_i)
+        out_i = \cos^{-1}(x_i)
 
     Args:
         x (COOTensor): Input COOTensor.
@@ -897,6 +943,8 @@ def coo_acos(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -932,6 +980,8 @@ def csr_floor(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -968,6 +1018,8 @@ def coo_floor(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -987,7 +1039,7 @@ def csr_atan(x: CSRTensor) -> CSRTensor:
 
     .. math::
 
-        out_i = tan^{-1}(x_i)
+        out_i = \tan^{-1}(x_i)
 
     Args:
         x (CSRTensor): The data type should be one of the following types: float16, float32.
@@ -1003,6 +1055,8 @@ def csr_atan(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -1018,12 +1072,12 @@ def csr_atan(x: CSRTensor) -> CSRTensor:
 
 
 def coo_atan(x: COOTensor) -> COOTensor:
-    """
+    r"""
     Computes the trigonometric inverse tangent of the input element-wise.
 
     .. math::
 
-        out_i = tan^{-1}(x_i)
+        out_i = \tan^{-1}(x_i)
 
     Args:
         x (COOTensor): The data type should be one of the following types: float16, float32.
@@ -1039,6 +1093,8 @@ def coo_atan(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -1073,6 +1129,8 @@ def csr_square(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -1108,6 +1166,8 @@ def coo_square(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -1145,6 +1205,8 @@ def csr_relu6(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -1183,6 +1245,8 @@ def coo_relu6(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -1217,6 +1281,8 @@ def csr_sinh(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -1252,6 +1318,8 @@ def coo_sinh(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -1287,6 +1355,8 @@ def csr_ceil(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -1323,6 +1393,8 @@ def coo_ceil(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -1360,6 +1432,8 @@ def csr_cosh(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -1398,6 +1472,8 @@ def coo_cosh(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -1434,6 +1510,8 @@ def csr_softsign(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -1471,6 +1549,8 @@ def coo_softsign(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -1489,7 +1569,7 @@ def csr_log1p(x: CSRTensor) -> CSRTensor:
     Returns the natural logarithm of one plus the input CSRTensor element-wise.
 
     .. math::
-        out_i = {log_e}(x_i + 1)
+        out_i = \text{log_e}(x_i + 1)
 
     Args:
         x (CSRTensor): The input CSRTensor. With float16 or float32 data type.
@@ -1506,6 +1586,8 @@ def csr_log1p(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -1525,7 +1607,7 @@ def coo_log1p(x: COOTensor) -> COOTensor:
     Returns the natural logarithm of one plus the input COOTensor element-wise.
 
     .. math::
-        out_i = {log_e}(x_i + 1)
+        out_i = \text{log_e}(x_i + 1)
 
     Args:
         x (COOTensor): The input COOTensor, should have dtype of float16 or float32
@@ -1542,6 +1624,8 @@ def coo_log1p(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -1576,6 +1660,8 @@ def csr_round(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -1611,6 +1697,8 @@ def coo_round(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -1648,6 +1736,8 @@ def csr_tanh(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU``  ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -1686,6 +1776,8 @@ def coo_tanh(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU``  ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -1720,6 +1812,8 @@ def csr_asinh(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -1755,6 +1849,8 @@ def coo_asinh(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -1789,6 +1885,8 @@ def csr_neg(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -1824,6 +1922,8 @@ def coo_neg(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -1858,6 +1958,8 @@ def csr_acosh(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -1878,7 +1980,7 @@ def coo_acosh(x: COOTensor) -> COOTensor:
 
     .. math::
 
-        out_i = \cosh^{-1}(input_i)
+        y_i = \cosh^{-1}(x_i)
 
     .. warning::
         Given an input COOTensor x, the function computes inverse hyperbolic cosine of every element.
@@ -1897,6 +1999,8 @@ def coo_acosh(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -1936,6 +2040,8 @@ def csr_isinf(x: CSRTensor) -> CSRTensor:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -1976,6 +2082,8 @@ def coo_isinf(x: COOTensor) -> COOTensor:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -1990,7 +2098,7 @@ def coo_isinf(x: COOTensor) -> COOTensor:
 
 
 def csr_atanh(x: CSRTensor) -> CSRTensor:
-    """
+    r"""
     Computes inverse hyperbolic tangent of the input element-wise.
 
     .. math::
@@ -2016,6 +2124,8 @@ def csr_atanh(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -2031,12 +2141,12 @@ def csr_atanh(x: CSRTensor) -> CSRTensor:
 
 
 def coo_atanh(x: COOTensor) -> COOTensor:
-    """
+    r"""
     Computes inverse hyperbolic tangent of the input element-wise.
 
     .. math::
 
-        out_i = tanh^{-1}(x_{i})
+        out_i = \tanh^{-1}(x_{i})
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
@@ -2056,6 +2166,8 @@ def coo_atanh(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -2095,6 +2207,8 @@ def csr_sigmoid(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -2135,6 +2249,8 @@ def coo_sigmoid(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -2169,6 +2285,8 @@ def csr_abs(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -2204,6 +2322,8 @@ def coo_abs(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -2218,12 +2338,12 @@ def coo_abs(x: COOTensor) -> COOTensor:
 
 
 def csr_sin(x: CSRTensor) -> CSRTensor:
-    """
+    r"""
     Computes sine of the input element-wise.
 
     .. math::
 
-        out_i = sin(x_i)
+        out_i = \sin(x_i)
 
     Args:
         x (CSRTensor): Input CSRTensor.
@@ -2240,6 +2360,8 @@ def csr_sin(x: CSRTensor) -> CSRTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, CSRTensor
         >>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
         >>> indices = Tensor([3, 0], dtype=mstype.int32)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
@@ -2255,12 +2377,12 @@ def csr_sin(x: CSRTensor) -> CSRTensor:
 
 
 def coo_sin(x: COOTensor) -> COOTensor:
-    """
+    r"""
     Computes sine of the input element-wise.
 
     .. math::
 
-        out_i = sin(x_i)
+        out_i = \sin(x_i)
 
     Args:
         x (COOTensor): Input COOTensor.
@@ -2277,6 +2399,8 @@ def coo_sin(x: COOTensor) -> COOTensor:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
         >>> values = Tensor([-1, 2], dtype=mstype.float32)
         >>> shape = (3, 4)
@@ -2290,14 +2414,16 @@ def coo_sin(x: COOTensor) -> COOTensor:
     return COOTensor(x.indices, math_func.sin(x.values), x.shape)
 
 
-__all__ = ["csr_cos", "csr_tan", "csr_exp", "csr_inv", "csr_relu", "csr_expm1", "csr_isfinite",
-           "csr_asin", "csr_sqrt", "csr_log", "csr_isnan", "csr_acos", "csr_floor", "csr_atan",
-           "csr_square", "csr_relu6", "csr_sinh", "csr_ceil", "csr_cosh", "csr_softsign",
-           "csr_log1p", "csr_round", "csr_tanh", "csr_asinh", "csr_neg", "csr_acosh", "csr_isinf",
-           "csr_atanh", "csr_sigmoid", "csr_abs", "csr_sin", "coo_cos", "coo_tan", "coo_exp",
-           "coo_inv", "coo_relu", "coo_expm1", "coo_isfinite", "coo_asin", "coo_sqrt", "coo_log",
-           "coo_isnan", "coo_acos", "coo_floor", "coo_atan", "coo_square", "coo_relu6", "coo_sinh",
-           "coo_ceil", "coo_cosh", "coo_softsign", "coo_log1p", "coo_round", "coo_tanh",
-           "coo_asinh", "coo_neg", "coo_acosh", "coo_isinf", "coo_atanh", "coo_sigmoid", "coo_abs",
-           "coo_sin"]
+__all__ = [
+    "csr_cos", "csr_tan", "csr_exp", "csr_inv", "csr_relu", "csr_expm1", "csr_isfinite",
+    "csr_asin", "csr_sqrt", "csr_log", "csr_isnan", "csr_acos", "csr_floor", "csr_atan",
+    "csr_square", "csr_relu6", "csr_sinh", "csr_ceil", "csr_cosh", "csr_softsign",
+    "csr_log1p", "csr_round", "csr_tanh", "csr_asinh", "csr_neg", "csr_acosh", "csr_isinf",
+    "csr_atanh", "csr_sigmoid", "csr_abs", "csr_sin", "coo_cos", "coo_tan", "coo_exp",
+    "coo_inv", "coo_relu", "coo_expm1", "coo_isfinite", "coo_asin", "coo_sqrt", "coo_log",
+    "coo_isnan", "coo_acos", "coo_floor", "coo_atan", "coo_square", "coo_relu6", "coo_sinh",
+    "coo_ceil", "coo_cosh", "coo_softsign", "coo_log1p", "coo_round", "coo_tanh",
+    "coo_asinh", "coo_neg", "coo_acosh", "coo_isinf", "coo_atanh", "coo_sigmoid", "coo_abs",
+    "coo_sin"
+]
 __all__.sort()