mindspore 2.2.14__cp37-cp37m-manylinux1_x86_64.whl → 2.3.0rc2__cp37-cp37m-manylinux1_x86_64.whl

mindspore/common/recompute.py

@@ -0,0 +1,247 @@
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Defines other operators with functional form."""
+
+from collections import OrderedDict
+from types import MethodType
+from mindspore import log as logger
+from mindspore.nn.cell import Cell
+from mindspore import context
+from mindspore.common.tensor import Tensor
+from mindspore.ops.composite import GradOperation
+from mindspore.common._register_for_recompute import recompute_registry
+from mindspore.common.api import _pynative_executor
+from mindspore.nn.generator import get_rng_state, set_rng_state
+
+
+class _WrapCell(Cell):
+    """
+    The warp cell is used by recompute cell,
+    which can set mixed precision to warp cell
+    """
+
+    def __init__(self, function):
+        super(_WrapCell, self).__init__()
+        self.function = function
+
+    def construct(self, *args, **kwargs):
+        return self.function(*args, **kwargs)
+
+
+class _RecomputeCell(Cell):
+    """
+    Recompute cell, given the sub block, this cell will recompute the block, rather than
+    storing the intermediate activation computed in forward pass, we will recompute it in backward pass.
+    Note:
+     - RecomputeCell now only support pynative mode.
+     - When use recompute function, block object should not decorated by @jit.
+    """
+
+    def __init__(self, block):
+        """Initialize Recompute cell."""
+        super(_RecomputeCell, self).__init__()
+        self.args = []
+        self.kwargs = []
+        self.wrap_cell = _WrapCell(block)
+        self.net = block
+        self.internal_params = []
+        self.save_rng_state = False
+        self.cpu_rng_state = None
+        self._add_attr("is_cell_recompute", "True")
+        self.grad = GradOperation(get_all=True, get_by_list=True, sens_param=True)
+        self.init_mixed_precision_type(block)
+
+    def construct(self, *args, **kwargs):
+        _check_input_args_validate(self.net, args)
+        self.args.append(args)
+        self.kwargs.append(kwargs)
+        self.save_rng_state = kwargs.pop("save_rng_state", True)
+        if self.save_rng_state:
+            self.cpu_rng_state = get_rng_state()
+        return self.net(*args, **kwargs)
+
+    def bprop(self, *args):
+        """
+        Custom grad method for recompute
+        :param args:
+        :return: input grad and weight grads
+        """
+        grad_input = args[-1]
+        input_args = self.args[-1]
+        kwargs = self.kwargs[-1]
+        self.args.pop()
+        self.kwargs.pop()
+        if kwargs:
+            input_args = list(input_args) + list(kwargs.values())
+        try:
+            pre_rng_state = get_rng_state()
+            set_rng_state(*self.cpu_rng_state)
+            _pynative_executor.set_is_run_recompute(True)
+            grads = self.grad(self.net, self.internal_params)(*input_args, grad_input)
+            _pynative_executor.set_is_run_recompute(False)
+            set_rng_state(*pre_rng_state)
+        except Exception as err:
+            _pynative_executor.clear_res()
+            raise err
+        weights = OrderedDict()
+        input_grads = list(grads[0])
+        _padding_input_grads(input_args, input_grads)
+        for i, param in enumerate(self.internal_params):
+            weights[param] = grads[1][i]
+        return tuple(input_grads), weights
+
+    def init_mixed_precision_type(self, block):
+        """
+        init mix precision
+        :param block:
+        :return:
+        """
+        if isinstance(block, Cell):
+            # To avoid sub cell same name
+            block.check_names_and_refresh_name()
+            self.internal_params = block.trainable_params()
+            return
+        if isinstance(block, MethodType) and isinstance(block.__self__, Cell):
+            # To avoid sub cell same name
+            block.__self__.check_names_and_refresh_name()
+            self.internal_params = block.__self__.trainable_params()
+            self.wrap_cell.set_mixed_precision_type(block.__self__.get_mixed_precision_type())
+            self.net = self.wrap_cell
+        else:
+            raise TypeError("For Recompute cell, it not support FunctionType function, "
+                            "only support Cell object or MethodType function!")
+
+
+def _check_input_args_validate(block, args):
+    """
+    Check recompute input args validate
+    :param args:
+    :return:
+    """
+    if not any([isinstance(arg, Tensor) for arg in args]):
+        logger.warning("None of the inputs of function are tensors, which not need use recompute!")
+    for arg in args:
+        if isinstance(arg, (tuple, list)):
+            for data in arg:
+                if isinstance(data, Tensor):
+                    logger.info("For recompute block {}, tensor input in Tuple or list "
+                                "will not calculate grads!".format(block))
+                    break
+
+
+def _padding_input_grads(args, input_grads):
+    """
+    Padding input grads to same as input args
+    :param args:
+    :param input_grads:
+    :return:
+    """
+    for i, arg in enumerate(args):
+        if isinstance(arg, (list, tuple)):
+            if all([not isinstance(data, Tensor) for data in arg]):
+                input_grads.insert(i, None)
+            else:
+                # None is placeholder
+                grads = [None for data in arg]
+                input_grads.insert(i, grads)
+        elif not isinstance(arg, Tensor):
+            input_grads.insert(i, None)
+    if len(args) != len(input_grads):
+        raise ValueError("For recompute cell, the input grads size should be same as input args size: {}, "
+                         "but got {}".format(len(args), len(input_grads)))
+
+
+def _check_validation(block):
+    if not isinstance(block, Cell):
+        raise TypeError("Recompute function now only support block which inherited from Cell!")
+    if context.get_context("mode") != context.PYNATIVE_MODE:
+        raise AssertionError("Recompute function now only support pynative mode, you can use "
+                             "Cell.recompute() in graph mode.")
+    if block.construct.__code__.co_name == "staging_specialize":
+        logger.warning('Block\'s construct method decorated by @jit that recompute '
+                       'function will not come into effect.')
+
+
+def recompute(block, *args, **kwargs):
+    r"""
+    This function is used to reduce memory, when run block, rather than
+    storing the intermediate activation computed in forward pass, we will recompute it in backward pass.
+
+    Note:
+        - Recompute function only support block which inherited from Cell object.
+        - This function interface now only support pynative mode. you can use Cell.recompute interface
+          in graph mode.
+        - When use recompute function, block object should not decorated by @jit.
+
+    Args:
+        block (Cell): Block to be recompute.
+        args(tuple): Inputs for block object to run forward pass.
+        kwargs(dict): Optional input for recompute function.
+
+    Returns:
+        Same as return type of block.
+
+    Raises:
+        TypeError: If `block` is not Cell object.
+        AssertionError: If execute mode is not PYNATIVE_MODE.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore.nn as nn
+        >>> import mindspore.ops as ops
+        >>> from mindspore import Tensor, recompute
+        >>> class MyCell(nn.Cell):
+        ...     def __init__(self):
+        ...         super(MyCell, self).__init__(auto_prefix=False)
+        ...         self.conv = nn.Conv2d(2, 2, 2, has_bias=False, weight_init='ones')
+        ...         self.relu = ops.ReLU()
+        ...
+        ...     def construct(self, x):
+        ...         y = recompute(self.conv, x)
+        ...         return self.relu(y)
+        >>> inputs = Tensor(np.ones([2, 2, 2, 2]).astype(np.float32) * 2)
+        >>> my_net = MyCell()
+        >>> grad = ops.grad(my_net)(inputs)
+        >>> print(grad)
+        [[[[2. 4.]
+           [4. 8.]]
+          [[2. 4.]
+           [4. 8.]]]
+         [[[2. 4.]
+           [4. 8.]]
+          [[2. 4.]
+           [4. 8.]]]]
+    """
+
+    _check_validation(block)
+    return _RecomputeCell(block)(*args, **kwargs)
+
+
+def recompute_generator(block):
+    """
+    generator of recompute object.
+    :param block:
+    :return:
+    """
+    return _RecomputeCell(block)
+
+
+recompute_registry.register(recompute_generator)
+
+__all__ = ['recompute']
+__all__.sort()

mindspore/common/seed.py

@@ -41,18 +41,18 @@ def set_seed(seed):
     Set global seed.
 
     Note:
-        The global seed is used by numpy.random, mindspore.common.Initializer and
-        mindspore.nn.probability.distribution.
+        - The global seed is used by numpy.random, mindspore.common.Initializer and
+          mindspore.nn.probability.distribution.
 
-        If global seed is not set, these packages will use their own default seed independently, numpy.random and
-        mindspore.common.Initializer will choose a random seed, mindspore.nn.probability.distribution will use zero.
+        - If global seed is not set, these packages will use their own default seed independently, numpy.random and
+          mindspore.common.Initializer will choose a random seed, mindspore.nn.probability.distribution will use zero.
 
-        Seed set by numpy.random.seed() only used by numpy.random, while seed set by this API will also used by
-        numpy.random, so just set all seed by this API is recommended.
+        - Seed set by numpy.random.seed() only used by numpy.random, while seed set by this API will also used by
+          numpy.random, so just set all seed by this API is recommended.
 
-        In semi_auto_parallel/auto_parallel mode, when using set_seed, weights with same shape and same sharding
-        strategy in the same device would be initialized to the same result, otherwise, they would be initialized to
-        the different result.
+        - In semi_auto_parallel/auto_parallel mode, when using set_seed, weights with same shape and same sharding
+          strategy in the same device would be initialized to the same result, otherwise, they would be initialized to
+          the different result.
 
     Args:
         seed (int): The seed to be set.

mindspore/common/sparse_tensor.py

@@ -226,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.2/note/static_graph_syntax_support.html#operators>`_.
+    `operators <https://www.mindspore.cn/docs/en/master/note/static_graph_syntax_support.html#operators>`_.
 
     .. warning::
         - This is an experimental API that is subject to change or deletion.
@@ -240,7 +240,7 @@ class COOTensor(COOTensor_):
             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`. Default: ``None`` .
-        shape (tuple(int)): An integer tuple of size `ndims`,
+        shape (tuple(int)): An integer tuple of shape :math:`(ndims)`,
             which specifies the dense_shape of the sparse tensor. Default: ``None`` .
         coo_tensor (COOTensor): A COOTensor object. Default: ``None`` .
 
@@ -351,22 +351,69 @@ class COOTensor(COOTensor_):
 
     @property
     def dtype(self) -> mstype:
-        """Return the dtype of the values of COOTensor (:class:`mindspore.dtype`)."""
+        """
+        Return the dtype of the values of COOTensor (:class:`mindspore.dtype`).
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, COOTensor
+            >>> indices = Tensor([[0, 1], [1, 2]], dtype=ms.int32)
+            >>> values = Tensor([1, 2], dtype=ms.float32)
+            >>> shape = (3, 4)
+            >>> coo_tensor = COOTensor(indices, values, shape)
+            >>> print(coo_tensor.dtype)
+            Float32
+        """
         return self._dtype
 
     @property
     def size(self) -> int:
-        """Return the number of non-zero values."""
+        """
+        Return the number of non-zero values.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, COOTensor
+            >>> indices = Tensor([[0, 1, 2], [1, 0, 2]], dtype=ms.int32)
+            >>> values = Tensor([1, 5, 4], dtype=ms.float32)
+            >>> shape = (3, 3)
+            >>> coo_tensor = COOTensor(indices.transpose(), values, shape)
+            >>> print(coo_tensor.size)
+            3
+        """
         return self.values.size
 
     @property
     def itemsize(self) -> int:
-        """Return the length of one tensor element in bytes."""
+        """
+        Return the length of one tensor element in bytes.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, COOTensor
+            >>> indices = Tensor([[0, 1], [1, 2]], dtype=ms.int32)
+            >>> values = Tensor([1, 2], dtype=ms.float64)
+            >>> shape = (3, 4)
+            >>> coo_tensor = COOTensor(indices, values, shape)
+            >>> print(coo_tensor.itemsize)
+            8
+        """
         return self.values.itemsize
 
     @property
     def ndim(self) -> int:
-        """Return the number of tensor dimensions."""
+        """
+        Return the number of tensor dimensions.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, COOTensor
+            >>> indices = Tensor([[0, 1], [1, 2]], dtype=ms.int32)
+            >>> values = Tensor([1, 2], dtype=ms.float32)
+            >>> coo_tensor = COOTensor(indices, values, (3, 4))
+            >>> print(coo_tensor.ndim)
+            2
+        """
         return len(self.shape)
 
     def coalesce(self) -> COOTensor:
@@ -408,6 +455,17 @@ class COOTensor(COOTensor_):
 
         Supported Platforms:
             ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, COOTensor
+            >>> indices = Tensor([[0, 1], [1, 2]], dtype=ms.int32)
+            >>> values = Tensor([1, 2], dtype=ms.int32)
+            >>> shape = (3, 4)
+            >>> coo_tensor = COOTensor(indices, values, shape)
+            >>> print(coo_tensor.to_csr())
+            CSRTensor(shape=[3, 4], dtype=Int32, indptr=Tensor(shape=[4], dtype=Int32, value=[0 1 2 2]),
+                indices=Tensor(shape=[2], dtype=Int32, value=[1 2]), values=Tensor(shape=[2], dtype=Int32, value=[1 2]))
         """
         row_indices = self.indices[:, 0]
         col_indices = self.indices[:, 1]
@@ -429,6 +487,18 @@ class COOTensor(COOTensor_):
 
         Supported Platforms:
             ``GPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, COOTensor
+            >>> indices = Tensor([[0, 1, 2], [1, 0, 2]], dtype=ms.int32)
+            >>> values = Tensor([1, 5, 4], dtype=ms.float32)
+            >>> shape = (3, 3)
+            >>> coo_tensor = COOTensor(indices.transpose(), values, shape)
+            >>> print(coo_tensor.to_dense())
+            [[0. 1. 0.]
+             [5. 0. 0.]
+             [0. 0. 4.]]
         """
         zeros_tensor = tensor_operator_registry.get("zeros")(self.shape, self.values.dtype)
         return tensor_operator_registry.get("tensor_scatter_add")(
@@ -469,6 +539,18 @@ class COOTensor(COOTensor_):
 
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, COOTensor
+            >>> indices = Tensor([[0, 1], [1, 2]], dtype=ms.int32)
+            >>> values = Tensor([1, 2], dtype=ms.float32)
+            >>> shape = (3, 4)
+            >>> coo_tensor = COOTensor(indices, values, shape)
+            >>> print(coo_tensor.to_tuple())
+            (Tensor(shape=[2, 2], dtype=Int32, value=
+            [[0, 1],
+             [1, 2]]), Tensor(shape=[2], dtype=Float32, value= [ 1.00000000e+00,  2.00000000e+00]), (3, 4))
         """
         return self.indices, self.values, self.shape
 
@@ -481,6 +563,17 @@ class COOTensor(COOTensor_):
 
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, COOTensor
+            >>> indices = Tensor([[0, 1, 2], [1, 0, 2]], dtype=ms.int32)
+            >>> values = Tensor([1, -5, -4], dtype=ms.float32)
+            >>> shape = (3, 3)
+            >>> coo_tensor = COOTensor(indices.transpose(), values, shape)
+            >>> res = coo_tensor.abs()
+            >>> print(res.values)
+            [1. 5. 4.]
         """
         data = self.values.abs()
         return COOTensor(self.indices, data, self.shape)
@@ -544,7 +637,7 @@ class COOTensor(COOTensor_):
 
 
 class CSRTensor(CSRTensor_):
-    """
+    r"""
     Constructs a sparse tensor in CSR (Compressed Sparse Row) format, with specified
     values indicated by `values` and row and column positions indicated by `indptr`
     and `indices`.
@@ -560,12 +653,12 @@ 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.2/note/static_graph_syntax_support.html#operators>`_.
+    `operators <https://www.mindspore.cn/docs/en/master/note/static_graph_syntax_support.html#operators>`_.
 
     .. warning::
         - This is an experimental API that is subjected to change.
         - If the values given by `indptr` or `indices` are invalid, the results may be undefined. Invalid values include
-          when the length of `values` or `indices` exceeds the range indicated by indptr, and when the columns
+          when the length of `values` or `indices` exceeds the range indicated by `indptr`, and when the columns
           indicated by `indices` are repeated on the same row.
 
     Args:
@@ -577,10 +670,10 @@ class CSRTensor(CSRTensor_):
             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``.
-        shape (tuple(int)): A tuple indicates the shape of the CSRTensor, and `shape[0]` must equal to `M - 1`,
+        shape (tuple(int)): An integer tuple of shape :math:`(ndims)`, and `shape[0]` must equal to `M - 1`,
             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 :math:`(values.shape[1:] == csr\_tensor.shape[2:])` . Default: ``None``.
 
     Outputs:
         CSRTensor, with shape defined by `shape`, and dtype inferred from `value`.
@@ -668,37 +761,128 @@ class CSRTensor(CSRTensor_):
 
     @property
     def indices(self) -> Tensor:
-        """Return CSRTensor's column indices."""
+        """
+        Return CSRTensor's column indices.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, CSRTensor
+            >>> indptr = Tensor([0, 1, 2], dtype=ms.int32)
+            >>> indices = Tensor([0, 1], dtype=ms.int32)
+            >>> values = Tensor([1, 2], dtype=ms.float32)
+            >>> shape = (2, 4)
+            >>> csr_tensor = CSRTensor(indptr, indices, values, shape)
+            >>> print(csr_tensor.indices)
+            [0 1]
+        """
         return Tensor(self._indices)
 
     @property
     def values(self) -> Tensor:
-        """Return CSRTensor's non-zero values."""
+        """
+        Return CSRTensor's non-zero values.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, CSRTensor
+            >>> indptr = Tensor([0, 1, 2], dtype=ms.int32)
+            >>> indices = Tensor([0, 1], dtype=ms.int32)
+            >>> values = Tensor([1, 2], dtype=ms.float32)
+            >>> shape = (2, 4)
+            >>> csr_tensor = CSRTensor(indptr, indices, values, shape)
+            >>> print(csr_tensor.values)
+            [1. 2.]
+        """
         return Tensor(self._values)
 
     @property
     def shape(self) -> Tuple[int, ...]:
-        """Return CSRTensor's shape."""
+        """
+        Return CSRTensor's shape.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, CSRTensor
+            >>> indptr = Tensor([0, 1, 2], dtype=ms.int32)
+            >>> indices = Tensor([0, 1], dtype=ms.int32)
+            >>> values = Tensor([1, 2], dtype=ms.float32)
+            >>> shape = (2, 4)
+            >>> csr_tensor = CSRTensor(indptr, indices, values, shape)
+            >>> print(csr_tensor.shape)
+            (2, 4)
+        """
         return self._shape
 
     @property
     def dtype(self) -> mstype:
-        """Return the dtype of the values of CSRTensor (:class:`mindspore.dtype`)."""
+        """
+        Return the dtype of the values of CSRTensor (:class:`mindspore.dtype`).
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, CSRTensor
+            >>> indptr = Tensor([0, 1, 2], dtype=ms.int32)
+            >>> indices = Tensor([0, 1], dtype=ms.int32)
+            >>> values = Tensor([1, 2], dtype=ms.float32)
+            >>> shape = (2, 4)
+            >>> csr_tensor = CSRTensor(indptr, indices, values, shape)
+            >>> print(csr_tensor.dtype)
+            Float32
+        """
         return self._dtype
 
     @property
     def size(self) -> int:
-        """Return the number of non-zero values."""
+        """
+        Return the number of non-zero values.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, CSRTensor
+            >>> indptr = Tensor([0, 1, 2], dtype=ms.int32)
+            >>> indices = Tensor([0, 1], dtype=ms.int32)
+            >>> values = Tensor([1, 2], dtype=ms.float32)
+            >>> shape = (2, 4)
+            >>> csr_tensor = CSRTensor(indptr, indices, values, shape)
+            >>> print(csr_tensor.size)
+            2
+        """
         return self.values.size
 
     @property
     def itemsize(self) -> int:
-        """Return the length of one tensor element in bytes."""
+        """
+        Return the length of one tensor element in bytes.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, CSRTensor
+            >>> indptr = Tensor([0, 1, 2], dtype=ms.int32)
+            >>> indices = Tensor([0, 1], dtype=ms.int32)
+            >>> values = Tensor([1, 2], dtype=ms.float64)
+            >>> shape = (2, 4)
+            >>> csr_tensor = CSRTensor(indptr, indices, values, shape)
+            >>> print(csr_tensor.itemsize)
+            8
+        """
         return self.values.itemsize
 
     @property
     def ndim(self) -> int:
-        """Return the number of tensor dimensions."""
+        """
+        Return the number of tensor dimensions.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, CSRTensor
+            >>> indptr = Tensor([0, 1, 2], dtype=ms.int32)
+            >>> indices = Tensor([0, 1], dtype=ms.int32)
+            >>> values = Tensor([1, 2], dtype=ms.float32)
+            >>> shape = (2, 4)
+            >>> csr_tensor = CSRTensor(indptr, indices, values, shape)
+            >>> print(csr_tensor.ndim)
+            2
+        """
         return len(self.shape)
 
     def to_tuple(self) -> Tuple[Tensor, Tensor, Tensor, Tuple[int, ...]]:
@@ -710,6 +894,19 @@ class CSRTensor(CSRTensor_):
 
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, CSRTensor
+            >>> indptr = Tensor([0, 1, 2], dtype=ms.int32)
+            >>> indices = Tensor([0, 1], dtype=ms.int32)
+            >>> values = Tensor([1, 2], dtype=ms.float32)
+            >>> shape = (2, 4)
+            >>> csr_tensor = CSRTensor(indptr, indices, values, shape)
+            >>> print(csr_tensor.to_tuple())
+            (Tensor(shape=[3], dtype=Int32, value= [0, 1, 2]), Tensor(shape=[2], dtype=Int32, value= [0, 1]),
+                Tensor(shape=[2], dtype=Float32, value= [ 1.00000000e+00,  2.00000000e+00]), (2, 4))
+
         """
         return self.indptr, self.indices, self.values, self.shape
 
@@ -725,6 +922,19 @@ class CSRTensor(CSRTensor_):
 
         Supported Platforms:
             ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, CSRTensor
+            >>> indptr = Tensor([0, 1, 2], dtype=ms.int32)
+            >>> indices = Tensor([0, 1], dtype=ms.int32)
+            >>> values = Tensor([1, 2], dtype=ms.int32)
+            >>> shape = (2, 4)
+            >>> csr_tensor = CSRTensor(indptr, indices, values, shape)
+            >>> print(csr_tensor.to_coo())
+            COOTensor(shape=[2, 4], dtype=Int32, indices=Tensor(shape=[2, 2], dtype=Int32, value=
+            [[0 0]
+             [1 1]]), values=Tensor(shape=[2], dtype=Int32, value=[1 2]))
         """
         if self.ndim != 2:
             raise ValueError("Currently only support 2-D CSRTensor when converting to COOTensor.")
@@ -741,6 +951,18 @@ class CSRTensor(CSRTensor_):
 
         Supported Platforms:
             ``GPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, CSRTensor
+            >>> indptr = Tensor([0, 1, 2], dtype=ms.int32)
+            >>> indices = Tensor([0, 1], dtype=ms.int32)
+            >>> values = Tensor([1, 2], dtype=ms.float32)
+            >>> shape = (2, 4)
+            >>> csr_tensor = CSRTensor(indptr, indices, values, shape)
+            >>> print(csr_tensor.to_dense())
+            [[1. 0. 0. 0.]
+             [0. 2. 0. 0.]]
         """
         return tensor_operator_registry.get("csr_to_dense")(self)
 
@@ -883,6 +1105,17 @@ class CSRTensor(CSRTensor_):
 
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, CSRTensor
+            >>> indptr = Tensor([0, 1, 2], dtype=ms.int32)
+            >>> indices = Tensor([0, 1], dtype=ms.int32)
+            >>> values = Tensor([-1, -2], dtype=ms.float32)
+            >>> shape = (2, 4)
+            >>> csr_tensor = CSRTensor(indptr, indices, values, shape)
+            >>> print(csr_tensor.abs().values)
+            [1. 2.]
         """
         data = self.values.abs()
         return CSRTensor(self.indptr, self.indices, data, self.shape)