mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/common/sparse_tensor.py

@@ -79,17 +79,16 @@ class RowTensor(RowTensorInner):
     """
     A sparse representation of a set of tensor slices at given indices.
 
-    An RowTensor is typically used to represent a subset of a larger
-    tensor dense of shape :math:`(L0, D1, .., DN)` where L0 >> D0.
+    When the `values` of a RowTensor has a shape of :math:`(d_0, d_1, ..., d_n)`, then this RowTensor is used to
+    represent a subset of a larger dense tensor of shape :math:`(l_0, d_1, ..., d_n)`, where :math:`d_i` is the size of
+    i-th axis in RowTensor, :math:`l_0` is the size of 0-th axis of dense tensor and it satisfies :math:`l_0 > d_0`.
 
-    The values in indices are the indices in the first dimension of the slices
-    that have been extracted from the larger tensor.
-
-    The dense tensor dense represented by an RowTensor slices has
-    `dense[slices.indices[i], :, :, :, ...] = slices.values[i, :, :, :, ...]`.
+    The parameter `indices` is used to specify locations from which the `RowTensor` is sliced in the first dimension of
+    the dense tensor, which means the parameters `indices` and `values` have the following relationship
+    :math:`dense[indices[i], :, :, :, ...] = values[i, :, :, :, ...]`.
 
     For example, if indices is [0], values is [[1, 2]], shape is
-     :math:`(3, 2)` , then the dense representation of the row tensor will be:
+    :math:`(3, 2)` , then the dense representation of the row tensor will be:
 
     .. code-block::
 
@@ -101,11 +100,11 @@ class RowTensor(RowTensorInner):
         This is an experimental API that is subjected to change or deletion.
 
     Args:
-        indices (Tensor): A 1-D integer Tensor of shape :math:`(D0)` . Default: None.
-        values (Tensor): A Tensor of any dtype of shape :math:`(D0, D1, ..., Dn)` . Default: None.
+        indices (Tensor): A 1-D integer Tensor of shape :math:`(d_0)` . Default: ``None``.
+        values (Tensor): A Tensor of any dtype of shape :math:`(d_0, d_1, ..., d_n)` . Default: ``None``.
         shape (tuple(int)): An integer tuple which contains the shape
-            of the corresponding dense tensor. Default: None.
-        row_tensor (RowTensor): A RowTensor object. Default: None.
+            of the corresponding dense tensor. Default: ``None``.
+        row_tensor (RowTensor): A RowTensor object. Default: ``None``.
 
     Returns:
         RowTensor, composed of `indices`, `values`, and `shape`.
@@ -151,7 +150,7 @@ class SparseTensor(COOTensor_):
 
     Note:
         The interface is deprecated from version 1.7 and will be removed in a future version.
-        Please use 'COOTensor' instead.
+        Please use :class:`mindspore.COOTensor` instead.
 
     Args:
         indices (Tensor): A 2-D integer Tensor of shape :math:`(N, ndims)`,
@@ -159,7 +158,7 @@ class SparseTensor(COOTensor_):
             the SparseTensor, respectively.
         values (Tensor): A 1-D tensor of any type and shape :math:`(N)`, which
             supplies the values for each element in `indices`.
-        shape (tuple(int)): An integer tuple of size `ndims`,
+        shape (tuple(int)): An integer tuple of size :math:`(ndims)`,
             which specifies the shape of the sparse tensor.
 
     Returns:
@@ -167,7 +166,6 @@ class SparseTensor(COOTensor_):
 
     Examples:
         >>> import mindspore as ms
-        >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, SparseTensor
         >>> indices = Tensor([[0, 1], [1, 2]])
         >>> values = Tensor([1, 2], dtype=ms.float32)
@@ -228,7 +226,7 @@ class COOTensor(COOTensor_):
 
     Common arithmetic operations include: addition (+), subtraction (-), multiplication (*),
     and division (/). For details about operations supported by `COOTensor`, see
-    `operators <https://www.mindspore.cn/docs/en/r2.0/note/static_graph_syntax_support.html#operators>`_.
+    `operators <https://www.mindspore.cn/docs/en/r2.2/note/static_graph_syntax_support.html#operators>`_.
 
     .. warning::
         - This is an experimental API that is subject to change or deletion.
@@ -238,20 +236,19 @@ class COOTensor(COOTensor_):
     Args:
         indices (Tensor): A 2-D integer Tensor of shape :math:`(N, ndims)`,
             where N and ndims are the number of `values` and number of dimensions in
-            the COOTensor, respectively. Currently, `ndims` must be 2.
+            the COOTensor, respectively. Currently, `ndims` must be 2. Default: ``None`` .
             Please make sure that the indices are in range of the given shape.
         values (Tensor): A 1-D tensor of any type and shape :math:`(N)`, which
-            supplies the values for each element in `indices`.
+            supplies the values for each element in `indices`. Default: ``None`` .
         shape (tuple(int)): An integer tuple of size `ndims`,
-            which specifies the dense_shape of the sparse tensor.
-        coo_tensor (COOTensor): A COOTensor object.
+            which specifies the dense_shape of the sparse tensor. Default: ``None`` .
+        coo_tensor (COOTensor): A COOTensor object. Default: ``None`` .
 
     Returns:
         COOTensor, composed of `indices`, `values`, and `shape`.
 
     Examples:
         >>> import mindspore as ms
-        >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, COOTensor
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=ms.int32)
         >>> values = Tensor([1, 2], dtype=ms.float32)
@@ -384,7 +381,6 @@ class COOTensor(COOTensor_):
 
         Examples:
             >>> import mindspore as ms
-            >>> import mindspore.ops as ops
             >>> from mindspore import Tensor, COOTensor
             >>> x_indices = Tensor([[0, 0, 1], [1, 1, 2]], dtype=ms.int64)
             >>> x_values = Tensor([1, 5, 4], dtype=ms.float32)
@@ -564,7 +560,7 @@ class CSRTensor(CSRTensor_):
 
     Common arithmetic operations include: addition (+), subtraction (-), multiplication (*),
     and division (/). For details about operations supported by `CSRTensor`, see
-    `operators <https://www.mindspore.cn/docs/en/r2.0/note/static_graph_syntax_support.html#operators>`_.
+    `operators <https://www.mindspore.cn/docs/en/r2.2/note/static_graph_syntax_support.html#operators>`_.
 
     .. warning::
         - This is an experimental API that is subjected to change.
@@ -574,17 +570,17 @@ class CSRTensor(CSRTensor_):
 
     Args:
         indptr (Tensor): 1-D Tensor of shape :math:`(M)`, which equals to `shape[0] + 1`, which indicates the
-            start and end point for `values` in each row. Default: None. If provided,
+            start and end point for `values` in each row. Default: ``None``. If provided,
             must be int16, int32 or int64.
         indices (Tensor): 1-D Tensor of shape :math:`(N)`, which has the same length as `values`. `indices`
-            indicates the which column `values` should be placed. Default: None. If provided,
+            indicates the which column `values` should be placed. Default: ``None``. If provided,
             must be int16, int32 or int64.
         values (Tensor): Tensor, which has the same length as `indices` (values.shape[0] == indices.shape[0]).
-            `values`  stores the data for CSRTensor. Default: None.
+            `values`  stores the data for CSRTensor. Default: ``None``.
         shape (tuple(int)): A tuple indicates the shape of the CSRTensor, and `shape[0]` must equal to `M - 1`,
-            which all equal to number of rows of the CSRTensor. Default: None.
+            which all equal to number of rows of the CSRTensor. Default: ``None``.
         csr_tensor (CSRTensor): A CSRTensor object.  Values' feature dimension should match with
-            CSRTensor's feature dimension (values.shape[1:] == csr_tensor.shape[2:]). Default: None.
+            CSRTensor's feature dimension (values.shape[1:] == csr_tensor.shape[2:]). Default: ``None``.
 
     Outputs:
         CSRTensor, with shape defined by `shape`, and dtype inferred from `value`.
@@ -817,7 +813,7 @@ class CSRTensor(CSRTensor_):
 
         Note:
             If right matrix is CSRTensor, currently only supports GPU backend.
-            if right matrix is Tensor, currently supports CPU backend with LLVM 12.0.1 or GPU backend.
+            If right matrix is Tensor, currently supports CPU backend with LLVM no lower than 12.0.1, and GPU backend.
 
         Args:
             matrix (Tensor or CSRTensor): A dense Tensor or CSRTensor,
@@ -919,9 +915,9 @@ class CSRTensor(CSRTensor_):
             >>> a = CSRTensor(indptr, indices, values_a, dense_shape)
             >>> b = CSRTensor(indptr, indices, values_b, dense_shape)
             >>> print(a.add(b, alpha, beta))
-                CSRTensor(shape=[2,4], dtype=Float32,
-                          indptr=Tensor(shape=[3], dtype=Int32, value = [0, 1, 2]),
-                          indices=Tensor(shape=[2], dtype=Int32, value = [0, 1]),
-                          values=Tensor(shape=[2], dtype=Float32, value = [3.0, 3.0]))
+            CSRTensor(shape=[2, 4], dtype=Float32,
+                      indptr=Tensor(shape=[3], dtype=Int32, value=[0 1 2]),
+                      indices=Tensor(shape=[2], dtype=Int32, value=[0 1]),
+                      values=Tensor(shape=[2], dtype=Float32, value=[ 3.00000000e+00  3.00000000e+00]))
         """
         return tensor_operator_registry.get('csr_add')(self, b, alpha, beta)