!26925 update api format

Merge pull request !26925 from yingchen/code_docs_api1129

docs/api/api_python/dataset/mindspore.dataset.GraphData.rst

@@ -11,9 +11,9 @@ mindspore.dataset.GraphData
     - **num_parallel_workers** (int, 可选)：读取数据的工作线程数（默认为None）。
     - **working_mode** (str, 可选)：设置工作模式，目前支持'local'/'client'/'server'（默认为'local'）。
 
-      -'local'，用于非分布式训练场景。
-      -'client'，用于分布式训练场景。客户端不加载数据，而是从服务器获取数据。
-      -'server'，用于分布式训练场景。服务器加载数据并可供客户端使用。
+      - 'local'，用于非分布式训练场景。
+      - 'client'，用于分布式训练场景。客户端不加载数据，而是从服务器获取数据。
+      - 'server'，用于分布式训练场景。服务器加载数据并可供客户端使用。
 
     - **hostname** (str, 可选)：图数据集服务器的主机名。该参数仅在工作模式设置为'client'或'server'时有效（默认为'127.0.0.1'）。
     - **port** (int, 可选)：图数据服务器的端口，取值范围为1024-65535。此参数仅当工作模式设置为'client'或'server'（默认为50051）时有效。
@@ -46,7 +46,7 @@ mindspore.dataset.GraphData
 
     **异常：**
 
-    **TypeError**：参数`edge_type`的类型不为整型。
+    **TypeError**：参数 `edge_type` 的类型不为整型。
 
 
 .. py:method:: get_all_neighbors(node_list, neighbor_type, output_format=<OutputFormat.NORMAL: 0。
@@ -181,7 +181,7 @@ mindspore.dataset.GraphData
 
     **异常：**
 
-    **TypeError**：参数`node_type`的类型不为整型。
+    **TypeError**：参数 `node_type` 的类型不为整型。
 
 
 .. py:method:: get_edges_from_nodes(node_list)

docs/api/api_python/dataset/mindspore.dataset.ImageFolderDataset.rst

@@ -5,7 +5,7 @@ mindspore.dataset.ImageFolderDataset
 
     从树状结构的文件目录中读取图像作为源数据集，同一个文件夹中的所有图像都具有相同的标签。
 
-    生成的数据集有两列： :py:obj:`[image, label]`。列:py:obj:`image` 的数据为uint8类型，列:py:obj:`label` 的数据是uint32类型的标量。
+    生成的数据集有两列：`[image, label]`。列: `image` 的数据为uint8类型，列: `label` 的数据是uint32类型的标量。
 
     **参数：**
 

docs/api/api_python/dataset/mindspore.dataset.MnistDataset.rst

@@ -1,7 +1,7 @@
 mindspore.dataset.MnistDataset
 ===============================
 
-.. py:class:: MnistDataset(dataset_dir, usage=None, num_samples=None, num_parallel_workers=None, shuffle=None, sampler=None, num_shards=None, shard_id=None, cache=None)
+.. py:class:: mindspore.dataset.MnistDataset(dataset_dir, usage=None, num_samples=None, num_parallel_workers=None, shuffle=None, sampler=None, num_shards=None, shard_id=None, cache=None)
 
     用于读取和解析MNIST数据集的源数据集文件。
 

docs/api/api_python/dataset/mindspore.dataset.SubsetSampler.rst

@@ -7,8 +7,8 @@ mindspore.dataset.SequentialSampler
 
     **参数：**
 
-        - **indices** (Any iterable Python object but string): 索引的序列。
-        - **num_samples** (int, optional): 要采样的元素数量（默认值为None，采样所有元素）。
+    - **indices** (Any iterable Python object but string): 索引的序列。
+    - **num_samples** (int, optional): 要采样的元素数量（默认值为None，采样所有元素）。
 
     **样例：**
 

docs/api/api_python/dataset/mindspore.dataset.WeightedRandomSampler.rst

@@ -15,7 +15,7 @@ mindspore.dataset.WeightedRandomSampler
 
     >>> weights = [0.9, 0.01, 0.4, 0.8, 0.1, 0.1, 0.3]
     >>>
-    >>> # 创建一个WeightedRandomSampler，在没有replacement的情况下对4个元素进行采样
+    >>> # 创建一个WeightedRandomSampler，将对4个元素进行有放回采样
     >>> sampler = ds.WeightedRandomSampler(weights, 4)
     >>> dataset = ds.ImageFolderDataset(image_folder_dataset_dir,
     ...                                 num_parallel_workers=8,

docs/api/api_python/dataset/mindspore.dataset.bucket_batch_by_length.rst

@@ -20,22 +20,22 @@
 
     **样例：**
     
-		>>> # 创建一个数据集对象，其中给定条数的数据会被组成一个批次数据
-		>>> # 如果最后一个批次数据小于给定的批次大小（batch_size)，则丢弃这个批次
-		>>> import numpy as np
-		>>> def generate_2_columns(n):
-		...     for i in range(n):
-		...         yield (np.array([i]), np.array([j for j in range(i + 1)]))
-		>>>
-		>>> column_names = ["col1", "col2"]
-		>>> dataset = ds.GeneratorDataset(generate_2_columns(8), column_names)
-		>>> bucket_boundaries = [5, 10]
-		>>> bucket_batch_sizes = [2, 1, 1]
-		>>> element_length_function = (lambda col1, col2: max(len(col1), len(col2)))
-		>>> # 将对列名为"col2"的列进行填充，填充后的shape为[bucket_boundaries[i]]，其中i是当前正在批处理的桶的索引
-		>>> pad_info = {"col2": ([None], -1)}
-		>>> pad_to_bucket_boundary = True
-		>>> dataset = dataset.bucket_batch_by_length(column_names, bucket_boundaries,
-		...                                          bucket_batch_sizes,
-		...                                          element_length_function, pad_info,
-		...                                          pad_to_bucket_boundary)
+	>>> # 创建一个数据集对象，其中给定条数的数据会被组成一个批次数据
+	>>> # 如果最后一个批次数据小于给定的批次大小（batch_size)，则丢弃这个批次
+	>>> import numpy as np
+	>>> def generate_2_columns(n):
+	...     for i in range(n):
+	...         yield (np.array([i]), np.array([j for j in range(i + 1)]))
+	>>>
+	>>> column_names = ["col1", "col2"]
+	>>> dataset = ds.GeneratorDataset(generate_2_columns(8), column_names)
+	>>> bucket_boundaries = [5, 10]
+	>>> bucket_batch_sizes = [2, 1, 1]
+	>>> element_length_function = (lambda col1, col2: max(len(col1), len(col2)))
+	>>> # 将对列名为"col2"的列进行填充，填充后的shape为[bucket_boundaries[i]]，其中i是当前正在批处理的桶的索引
+	>>> pad_info = {"col2": ([None], -1)}
+	>>> pad_to_bucket_boundary = True
+	>>> dataset = dataset.bucket_batch_by_length(column_names, bucket_boundaries,
+	...                                          bucket_batch_sizes,
+	...                                          element_length_function, pad_info,
+	...                                          pad_to_bucket_boundary)

docs/api/api_python/dataset/mindspore.dataset.zip.rst

@@ -4,7 +4,7 @@
 
     **参数：**
 
-    - **datasets** (tuple of class Dataset) - 输入元组格式的多个dataset对象。 `datasets` 参数的长度必须大于1。
+    **datasets** (tuple of class Dataset) - 输入元组格式的多个dataset对象。 `datasets` 参数的长度必须大于1。
 
     **返回：**
 

docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.LowpassBiquad.rst

@@ -7,9 +7,9 @@ mindspore.dataset.audio.transforms.LowpassBiquad
 
     **参数：**
 
-        - **sample_rate** (int)：采样率，例如44100 (Hz)，不能为零。
-        - **cutoff_freq** (float)：中心频率（单位：Hz）。
-        - **Q** (float, optional)：品质因子，参考https://en.wikipedia.org/wiki/Q_factor，取值范围(0, 1]（默认值为0.707）。
+    - **sample_rate** (int)：采样率，例如44100 (Hz)，不能为零。
+    - **cutoff_freq** (float)：中心频率（单位：Hz）。
+    - **Q** (float, optional)：品质因子，参考https://en.wikipedia.org/wiki/Q_factor，取值范围(0, 1]（默认值为0.707）。
 
     **样例：**
 

docs/api/api_python/mindspore/mindspore.Parameter.rst

@@ -13,11 +13,11 @@
 
     **参数：**
 
-        - **default_input** (Union[Tensor, int, float, numpy.ndarray, list])：初始化参数的输入值。
-        - **name** (str)：参数的名称。默认值：None。
-        - **requires_grad** (bool)：是否需要微分求梯度。默认值：True。
-        - **layerwise_parallel** (bool)：在数据/混合并行模式下， `layerwise_parallel` 配置为True时，参数广播和梯度聚合时会过滤掉该参数。默认值：False。
-        - **parallel_optimizer** (bool)：用于在 `semi_auto_parallel` 或 `auto_parallel` 并行模式下区分参数是否进行优化器切分。仅在 `mindspore.context.set_auto_parallel_context()` 并行配置模块中设置 `enable_parallel_optimizer` 启用优化器并行时有效。默认值：True。
+    - **default_input** (Union[Tensor, int, float, numpy.ndarray, list])：初始化参数的输入值。
+    - **name** (str)：参数的名称。默认值：None。
+    - **requires_grad** (bool)：是否需要微分求梯度。默认值：True。
+    - **layerwise_parallel** (bool)：在数据/混合并行模式下， `layerwise_parallel` 配置为True时，参数广播和梯度聚合时会过滤掉该参数。默认值：False。
+    - **parallel_optimizer** (bool)：用于在 `semi_auto_parallel` 或 `auto_parallel` 并行模式下区分参数是否进行优化器切分。仅在 `mindspore.context.set_auto_parallel_context()` 并行配置模块中设置 `enable_parallel_optimizer` 启用优化器并行时有效。默认值：True。
 
     **样例：**
 

docs/api/api_python/mindspore/mindspore.RowTensor.rst

@@ -7,45 +7,43 @@ mindspore.RowTensor
 
     通常用于表示一个有着形状为[L0, D1, .., DN]的更大的稠密张量（其中L0>>D0）的子集。
 
-    其中，参数`indices`用于指定`RowTensor`从该稠密张量的第一维度的哪些位置来进行切片。
+    其中，参数 `indices` 用于指定 `RowTensor` 从该稠密张量的第一维度的哪些位置来进行切片。
 
-    由`RowTensor`切片表示的稠密张量具有以下属性： `dense[slices.indices[i], :, :, :, ...] = slices.values[i, :, :, :, ...]` 。
+    由 `RowTensor` 切片表示的稠密张量具有以下属性： `dense[slices.indices[i], :, :, :, ...] = slices.values[i, :, :, :, ...]` 。
 
-    `RowTensor`只能在 `Cell` 的构造方法中使用。
+    `RowTensor` 只能在  `Cell` 的构造方法中使用。
 
     目前不支持PyNative模式。
 
     **参数：**
 
-        - **indices** (Tensor)：形状为[D0]的一维整数张量。
-        - **values** (Tensor)：形状为[D0, D1, ..., Dn]中任意类型的张量。
-        - **dense_shape** (tuple(int))：包含相应稠密张量形状的整数元组。
+    - **indices** (Tensor)：形状为[D0]的一维整数张量。
+    - **values** (Tensor)：形状为[D0, D1, ..., Dn]中任意类型的张量。
+    - **dense_shape** (tuple(int))：包含相应稠密张量形状的整数元组。
 
     **返回：**
 
-        RowTensor，由 `indices` 、 `values` 和 `dense_shape` 组成。
+    RowTensor，由 `indices` 、 `values` 和 `dense_shape` 组成。
 
     **样例：**
 
-        .. code-block::
-
-            >>> import mindspore as ms
-            >>> import mindspore.nn as nn
-            >>> from mindspore import RowTensor
-            >>> class Net(nn.Cell):
-            ...     def __init__(self, dense_shape)：
-            ...         super(Net, self).__init__()
-            ...         self.dense_shape = dense_shape
-            ...     def construct(self, indices, values)：
-            ...         x = RowTensor(indices, values, self.dense_shape)
-            ...         return x.values, x.indices, x.dense_shape
-            >>>
-            >>> indices = Tensor([0])
-            >>> values = Tensor([[1, 2]], dtype=ms.float32)
-            >>> out = Net((3, 2))(indices, values)
-            >>> print(out[0])
-            [[1.2.]]
-            >>> print(out[1])
-            [0]
-            >>> print(out[2])
-            (3, 2)
+    >>> import mindspore as ms
+    >>> import mindspore.nn as nn
+    >>> from mindspore import RowTensor
+    >>> class Net(nn.Cell):
+    ...     def __init__(self, dense_shape)：
+    ...         super(Net, self).__init__()
+    ...         self.dense_shape = dense_shape
+    ...     def construct(self, indices, values)：
+    ...         x = RowTensor(indices, values, self.dense_shape)
+    ...         return x.values, x.indices, x.dense_shape
+    >>>
+    >>> indices = Tensor([0])
+    >>> values = Tensor([[1, 2]], dtype=ms.float32)
+    >>> out = Net((3, 2))(indices, values)
+    >>> print(out[0])
+    [[1.2.]]
+    >>> print(out[1])
+    [0]
+    >>> print(out[2])
+    (3, 2)

docs/api/api_python/mindspore/mindspore.SparseTensor.rst

@@ -5,44 +5,42 @@ mindspore.SparseTensor
 
     用来表示某一张量在给定索引上非零元素的集合。
 
-    `SparseTensor`只能在 `Cell` 的构造方法中使用。
+    `SparseTensor` 只能在  `Cell` 的构造方法中使用。
 
     目前不支持PyNative模式。
 
-    对于稠密张量，其`SparseTensor(indices, values, dense_shape)`具有 `dense[indices[i]] = values[i]` 。
+    对于稠密张量，其 `SparseTensor(indices, values, dense_shape)` 具有 `dense[indices[i]] = values[i]` 。
 
     **参数：**
 
-        - **indices** (Tensor)：形状为 `[N, ndims]` 的二维整数张量，其中N和ndims分别表示稀疏张量中 `values` 的数量和SparseTensor维度的数量。
-        - **values** (Tensor)：形状为[N]的一维张量，其内部可以为任何数据类型，用来给 `indices` 中的每个元素提供数值。
-        - **dense_shape** (tuple(int))：形状为ndims的整数元组，用来指定稀疏矩阵的稠密形状。
+    - **indices** (Tensor)：形状为 `[N, ndims]` 的二维整数张量，其中N和ndims分别表示稀疏张量中 `values` 的数量和SparseTensor维度的数量。
+    - **values** (Tensor)：形状为[N]的一维张量，其内部可以为任何数据类型，用来给 `indices` 中的每个元素提供数值。
+    - **dense_shape** (tuple(int))：形状为ndims的整数元组，用来指定稀疏矩阵的稠密形状。
 
     **返回：**
 
-        SparseTensor，由 `indices` 、 `values` 和 `dense_shape` 组成。
+    SparseTensor，由 `indices` 、 `values` 和 `dense_shape` 组成。
 
     **样例：**
 
-        .. code-block::
-
-            >>> import mindspore as ms
-            >>> import mindspore.nn as nn
-            >>> from mindspore import SparseTensor
-            >>> class Net(nn.Cell)：
-            ...     def __init__(self, dense_shape)：
-            ...         super(Net, self).__init__()
-            ...         self.dense_shape = dense_shape
-            ...     def construct(self, indices, values)：
-            ...         x = SparseTensor(indices, values, self.dense_shape)
-            ...         return x.values, x.indices, x.dense_shape
-            >>>
-            >>> indices = Tensor([[0, 1], [1, 2]])
-            >>> values = Tensor([1, 2], dtype=ms.float32)
-            >>> out = Net((3, 4))(indices, values)
-            >>> print(out[0])
-            [1.2.]
-            >>> print(out[1])
-            [[0 1]
-            [1 2]]
-            >>> print(out[2])
-            (3, 4)
+    >>> import mindspore as ms
+    >>> import mindspore.nn as nn
+    >>> from mindspore import SparseTensor
+    >>> class Net(nn.Cell)：
+    ...     def __init__(self, dense_shape)：
+    ...         super(Net, self).__init__()
+    ...         self.dense_shape = dense_shape
+    ...     def construct(self, indices, values)：
+    ...         x = SparseTensor(indices, values, self.dense_shape)
+    ...         return x.values, x.indices, x.dense_shape
+    >>>
+    >>> indices = Tensor([[0, 1], [1, 2]])
+    >>> values = Tensor([1, 2], dtype=ms.float32)
+    >>> out = Net((3, 4))(indices, values)
+    >>> print(out[0])
+    [1.2.]
+    >>> print(out[1])
+    [[0 1]
+    [1 2]]
+    >>> print(out[2])
+    (3, 4)

docs/api/api_python/mindspore/mindspore.Tensor.rst

@@ -3,43 +3,41 @@ mindspore.Tensor
 
 .. py:class:: mindspore.Tensor(input_data=None, dtype=None, shape=None, init=None)
 
-    用来存储数据。 继承自C++中的`Tensor`对象。有些函数是用C++实现的，有些函数是用Python实现的。
+    用来存储数据。 继承自C++中的 `Tensor` 对象。有些函数是用C++实现的，有些函数是用Python实现的。
 
     **参数：**
 
-        - **input_data** (Union[Tensor, float, int, bool, tuple, list, numpy.ndarray])：张量的输入数据。
-        - **dtype** (:class:`mindspore.dtype`)：输入数据应是在 `mindspore.dtype` 中定义的None、bool或numeric类型。该参数用于定义输出张量的数据类型。如果值为None，则输出张量的数据类型与 `input_data` 的相同。默认值：None。
-        - **shape** (Union[tuple, list, int])：用来表示张量的形状，可以是整数列表、整数元组或单一整数。如果 `input_data` 已经被设置，则不需要再设置 `shape` 。默认值：None。
-        - **init** (Initializer)：用来表示初始化数据的信息。init用于在并行模式下的延迟初始化。一般情况下，不建议在其他条件下使用init接口来初始化参数。如果使用init接口来初始化参数，需要调用 `Tensor.init_data` 接口把 `Tensor` 转换为实际数据。
+    - **input_data** (Union[Tensor, float, int, bool, tuple, list, numpy.ndarray])：张量的输入数据。
+    - **dtype** (:class:`mindspore.dtype`)：输入数据应是在 `mindspore.dtype` 中定义的None、bool或numeric类型。该参数用于定义输出张量的数据类型。如果值为None，则输出张量的数据类型与 `input_data` 的相同。默认值：None。
+    - **shape** (Union[tuple, list, int])：用来表示张量的形状，可以是整数列表、整数元组或单一整数。如果 `input_data` 已经被设置，则不需要再设置 `shape` 。默认值：None。
+    - **init** (Initializer)：用来表示初始化数据的信息。init用于在并行模式下的延迟初始化。一般情况下，不建议在其他条件下使用init接口来初始化参数。如果使用init接口来初始化参数，需要调用 `Tensor.init_data` 接口把 `Tensor` 转换为实际数据。
 
     **返回：**
 
-        Tensor。如果未设置 `dtype` 和 `shape` ，返回与 `input_data` 具有相同数据类型和形状的张量。如果设置了 `dtype` 或 `shape` ，则输出的张量的数据类型或形状与设置的相同。
+    Tensor。如果未设置 `dtype` 和 `shape` ，返回与 `input_data` 具有相同数据类型和形状的张量。如果设置了 `dtype` 或 `shape` ，则输出的张量的数据类型或形状与设置的相同。
 
     **样例：**
 
-        .. code-block::
-
-            >>> import numpy as np
-            >>> import mindspore as ms
-            >>> from mindspore import Tensor
-            >>> from mindspore.common.initializer import One
-            >>> # 用numpy.ndarray初始化张量
-            >>> t1 = Tensor(np.zeros([1, 2, 3]), ms.float32)
-            >>> assert isinstance(t1, Tensor)
-            >>> assert t1.shape == (1, 2, 3)
-            >>> assert t1.dtype == ms.float32
-            >>>
-            >>> # 用float标量初始化张量
-            >>> t2 = Tensor(0.1)
-            >>> assert isinstance(t2, Tensor)
-            >>> assert t2.dtype == ms.float64
-            ...
-            >>> # 用init初始化张量
-            >>> t3 = Tensor(shape = (1, 3), dtype=ms.float32, init=One())
-            >>> assert isinstance(t3, Tensor)
-            >>> assert t3.shape == (1, 3)
-            >>> assert t3.dtype == ms.float32
+    >>> import numpy as np
+    >>> import mindspore as ms
+    >>> from mindspore import Tensor
+    >>> from mindspore.common.initializer import One
+    >>> # 用numpy.ndarray初始化张量
+    >>> t1 = Tensor(np.zeros([1, 2, 3]), ms.float32)
+    >>> assert isinstance(t1, Tensor)
+    >>> assert t1.shape == (1, 2, 3)
+    >>> assert t1.dtype == ms.float32
+    >>>
+    >>> # 用float标量初始化张量
+    >>> t2 = Tensor(0.1)
+    >>> assert isinstance(t2, Tensor)
+    >>> assert t2.dtype == ms.float64
+    ...
+    >>> # 用init初始化张量
+    >>> t3 = Tensor(shape = (1, 3), dtype=ms.float32, init=One())
+    >>> assert isinstance(t3, Tensor)
+    >>> assert t3.shape == (1, 3)
+    >>> assert t3.dtype == ms.float32
 
     .. py:method:: T
         :property:
@@ -53,21 +51,19 @@ mindspore.Tensor
 
         **返回：**
 
-            张量， 含有每个元素的绝对值。
+        张量， 含有每个元素的绝对值。
 
         **支持平台：**
 
-            ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
         **样例：**
 
-            .. code-block::
-
-                >>> from mindspore import Tensor
-                >>> a = Tensor([1.1, -2.1]).astype("float32")
-                >>> output = a.abs()
-                >>> print(output)
-                [1.1 2.1]
+        >>> from mindspore import Tensor
+        >>> a = Tensor([1.1, -2.1]).astype("float32")
+        >>> output = a.abs()
+        >>> print(output)
+        [1.1 2.1]
 
 
     .. py:method:: all(axis=(), keep_dims=False)
@@ -76,26 +72,24 @@ mindspore.Tensor
 
         **参数：**
 
-            - **axis** (Union[None, int, tuple(int))：被简化的维度。 当`axis`为None或者空元组的时候，简化所有维度。 默认值：()。
-            - **keep_dims** (bool)：是否会保留被简化的维度。 默认值： False。
+        - **axis** (Union[None, int, tuple(int))：被简化的维度。 当 `axis` 为None或者空元组的时候，简化所有维度。 默认值：()。
+        - **keep_dims** (bool)：是否会保留被简化的维度。 默认值： False。
 
         **返回：**
 
-            Tensor。如果在指定轴方向上所有数组元素都为True，则其值为True，否则其值为False。如果轴为None或空元组，则简化所有维度。
+        Tensor。如果在指定轴方向上所有数组元素都为True，则其值为True，否则其值为False。如果轴为None或空元组，则简化所有维度。
 
         **支持平台：**
 
-            ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
         **样例：**
 
-            .. code-block::
-
-                >>> from mindspore import Tensor
-                >>> a = Tensor([True, True, False])
-                >>> output = a.all()
-                >>> print(output)
-                False
+        >>> from mindspore import Tensor
+        >>> a = Tensor([True, True, False])
+        >>> output = a.all()
+        >>> print(output)
+        False
 
     .. py:method:: any(axis=(), keep_dims=False)
 
@@ -103,26 +97,24 @@ mindspore.Tensor
 
         **参数：**
 
-            - **axis** (Union[None, int, tuple(int))：简化的维度。当轴为None或空元组时，简化所有维度。默认值：()。
-            - **keep_dims** (bool)：表示是否保留简化后的维度。默认值：False。
+        - **axis** (Union[None, int, tuple(int))：简化的维度。当轴为None或空元组时，简化所有维度。默认值：()。
+        - **keep_dims** (bool)：表示是否保留简化后的维度。默认值：False。
 
         **返回：**
 
-            Tensor。如果在指定轴方向上所有数组元素都为True，则其值为True，否则其值为False。如果轴为None或空元组，则简化所有维度。
+        Tensor。如果在指定轴方向上所有数组元素都为True，则其值为True，否则其值为False。如果轴为None或空元组，则简化所有维度。
 
         **支持平台：**
 
-            ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
         **样例：**
 
-            .. code-block::
-
-                >>> from mindspore import Tensor
-                >>> a = Tensor([True, True, False])
-                >>> output = a.any()
-                >>> print(output)
-                True
+        >>> from mindspore import Tensor
+        >>> a = Tensor([True, True, False])
+        >>> output = a.any()
+        >>> print(output)
+        True
 
     .. py:method:: asnumpy()
 
@@ -139,11 +131,11 @@ mindspore.Tensor
 
         **参数：**
 
-            - **x** (Tensor)：输入的张量。该张量的形状必须遵守广播规则。
+        **x** (Tensor)：输入的张量。该张量的形状必须遵守广播规则。
 
         **返回：**
 
-            Tensor，维度与输入张量的相同。
+        Tensor，维度与输入张量的相同。
 
     .. py:method:: from_numpy(array)
         :static:
@@ -152,11 +144,11 @@ mindspore.Tensor
 
         **参数：**
 
-            array (numpy.array)：输入数组。
+        array (numpy.array)：输入数组。
 
         **返回：**
 
-            Tensor，与输入的张量具有相同的数据类型。
+        Tensor，与输入的张量具有相同的数据类型。
 
 
     .. py:method:: mean(axis=(), keep_dims=False)
@@ -165,24 +157,22 @@ mindspore.Tensor
 
         **参数：**
 
-            - **axis** (Union[None, int, tuple(int), list(int)])：简化的维度。当轴为None或空元组时，简化所有维度。默认值：()。
-            - **keep_dims** (bool)：表示是否保留简化后的维度。默认值：False。
+        - **axis** (Union[None, int, tuple(int), list(int)])：简化的维度。当轴为None或空元组时，简化所有维度。默认值：()。
+        - **keep_dims** (bool)：表示是否保留简化后的维度。默认值：False。
 
         **返回：**
 
-            Tensor，与输入的张量具有相同的数据类型。
+        Tensor，与输入的张量具有相同的数据类型。
 
         **支持平台：**
 
-            ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
         **样例：**
 
-            .. code-block::
-
-                >>> import numpy as np
-                >>> from mindspore import Tensor
-                >>> input_x = Tensor(np.array([1, 2, 3], dtype=np.float32))
-                >>> output = input_x.mean()
-                >>> print(output)
-                2.0
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> input_x = Tensor(np.array([1, 2, 3], dtype=np.float32))
+        >>> output = input_x.mean()
+        >>> print(output)
+        2.0