mindspore 2.2.14__cp38-cp38-manylinux1_x86_64.whl → 2.3.0rc2__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/function/other_func.py

@@ -12,11 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-
 """Defines other operators with functional form."""
-
 from mindspore.ops import operations as P
-from mindspore.ops._primitive_cache import _get_cache_prim
+
+
+partial_ = P.Partial()
+depend_ = P.Depend()
 
 
 def partial(func, *args):
@@ -49,7 +50,6 @@ def partial(func, *args):
         (Tensor(shape=[], dtype=Int64, value= 1), Tensor(shape=[], dtype=Int64, value= 3), Tensor(shape=[], dtype=Int64,
          value= 4))
     """
-    partial_ = _get_cache_prim(P.Partial)()
     return partial_(func, *args)
 
 
@@ -104,7 +104,6 @@ def depend(value, expr):
          [0.2 0.2 0.2 0.2 0.2]
          [0.2 0.2 0.2 0.2 0.2]]
     """
-    depend_ = _get_cache_prim(P.Depend)()
     return depend_(value, expr)
 
 

mindspore/ops/function/parameter_func.py

@@ -17,48 +17,11 @@
 
 from mindspore.ops import operations as P
 from mindspore.ops._primitive_cache import _get_cache_prim
-
-assign_ = P.Assign()
-
-
-def assign(variable, value):
-    """
-    Assigns `Parameter` with a value.
-
-    Args of `variable` and `value` comply with the implicit type conversion rules to make the data types consistent.
-    If they have different data types, the lower priority data type will be converted to
-    the relatively highest priority data type.
-
-    Args:
-        variable (Parameter): The `Parameter`. :math:`(N,*)` where :math:`*` means,
-            any number of additional dimensions.
-        value (Tensor): The value to be assigned, has the same shape with `variable`.
-
-    Returns:
-        Tensor, has the same data type and shape as original `variable`.
-
-    Raises:
-        TypeError: If `variable` is not a Parameter.
-        TypeError: If `value` is not a Tensor.
-        RuntimeError: If the data type of `variable` and `value` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> value = Tensor([2.0], mindspore.float32)
-        >>> variable = mindspore.Parameter(Tensor([1.0], mindspore.float32), name="variable")
-        >>> ops.assign(variable, value)
-        >>> print(variable.asnumpy())
-        [2.]
-    """
-    return assign_(variable, value)
+from mindspore.ops.auto_generate import assign, assign_add
 
 
 assign_sub_ = P.AssignSub()
+assign_add_ = P.AssignAdd()
 
 
 def assign_sub(variable, value):
@@ -109,57 +72,6 @@ def assign_sub(variable, value):
     return assign_sub_(variable, value)
 
 
-assign_add_ = P.AssignAdd()
-
-
-def assign_add(variable, value):
-    """
-    Updates a `Parameter` by adding a value to it.
-
-    Args of `variable` and `value` comply with the implicit type conversion rules to make the data types consistent.
-    If they have different data types, the lower priority data type will be converted to
-    the relatively highest priority data type.
-    If `value` is a number, the number is automatically converted to Tensor,
-    and the data type is consistent with the Tensor data type involved in the operation.
-
-    Note:
-        Since `variable` is a data type Parameter, the data type cannot be changed,
-        so only the type of `value` is allowed to be promoted to the type of `variable`.
-        And the conversion type supported by different devices will be different,
-        it is recommended to use the same data type when using this operator.
-
-    Args:
-        variable (Parameter): The `Parameter`.
-            :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
-        value (Tensor): The value to be added to the `variable`.
-            It must have the same shape as `variable`.
-            it is recommended to use the same data type when using this operator.
-
-    Returns:
-        Tensor, has the same data type and shape as original `variable`.
-
-    Raises:
-        TypeError: If `value` is neither Number nor Tensor.
-        RuntimeError: If the data type of `variable` and `value` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> from mindspore.common.initializer import initializer
-        >>> variable = mindspore.Parameter(initializer(1, [1], mindspore.int32), name="global_step")
-        >>> value = Tensor(np.ones([1]).astype(np.int32) * 100)
-        >>> ops.assign_add(variable, value)
-        >>> print(variable.asnumpy())
-        [101]
-    """
-    return assign_add_(variable, value)
-
-
 def index_add(x, indices, y, axis, use_lock=True, check_index_bound=True):
     """
     Adds tensor `y` to specified axis and indices of Parameter `x`. The axis should be in [0,  len(x.dim) - 1],
@@ -174,12 +86,12 @@ def index_add(x, indices, y, axis, use_lock=True, check_index_bound=True):
         y (Tensor): The input tensor with the value to add. Must have same data type as `x`.
             The shape must be the same as `x` except the `axis` th dimension.
         axis (int): The dimension along which to index.
-        use_lock (bool): Whether to enable a lock to protect the updating process of variable tensors.
+        use_lock (bool, optional): Whether to enable a lock to protect the updating process of variable tensors.
             If ``True`` , when updating the value of `x`, this process will be protected by a lock by using atomic
             operation.
             If ``False`` , the result may be unpredictable. Default: ``True`` .
-        check_index_bound (bool): If True, check index boundary. If ``False`` , don't check index boundary.
-            Default: ``True`` .
+        check_index_bound (bool, optional): If ``True``, check index boundary. If ``False`` ,
+            don't check index boundary. Default: ``True`` .
 
     Returns:
         Tensor, has the same shape and dtype as `x`.

mindspore/ops/function/random_func.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
+# 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.
@@ -25,10 +25,20 @@ from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_util
 from mindspore.common import dtype as mstype
 from mindspore.common.seed import _get_graph_seed
 from mindspore.common.tensor import Tensor
-from mindspore.ops.operations.random_ops import RandomShuffle, RandomChoiceWithMask, RandpermV2
-from mindspore.ops._primitive_cache import _get_cache_prim
+from mindspore.ops.operations.random_ops import RandomShuffle, RandomChoiceWithMask
 from mindspore.common.api import _function_forbid_reuse
-
+from mindspore.ops.auto_generate import randperm
+from mindspore.nn.generator import default_generator
+from mindspore.ops.auto_generate import UniformExt, NormalExt
+
+normal_ext_op = NormalExt()
+cast_ = P.Cast()
+log_ = P.Log()
+real_div_ = P.RealDiv()
+reshape_ = P.Reshape()
+shape_ = P.Shape()
+top_k_ = P.TopK()
+uniform_ = UniformExt()
 
 @constexpr
 def _set_prim_op_user_data(prim, key, value):
@@ -227,6 +237,37 @@ def multinomial_with_replacement(x, seed, offset, numsamples, replacement=False)
     return multinomial_with_replacement_(x, seed, offset)
 
 
+@_function_forbid_reuse
+def uniform_ext(tensor, a, b, generator=None):
+    """
+    Generates random numbers in the half-open interval [a, b).
+
+    Args:
+        tensor (Tensor): The origin input tensor.
+        a (float): The lower bound of the interval.
+        b (float): The upper bound of the interval.
+        generator (Generator, optional): The random seed. Default: None.
+
+    Raises:
+        TypeError: If `a` is larger than `b`.
+
+    Returns:
+        Tensor, with the same shape as tensor.
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> import mindspore
+        >>> import numpy as np
+        >>> x = mindspore.ops.ones(4, 2)
+        >>> output = ops.uniform_ext(x, 1., 2.)
+        >>> print(result)
+    """
+    if generator is None:
+        generator = default_generator()
+    seed, offset = generator(1)
+    return uniform_(tensor, a, b, seed, offset)
+
+
 @_function_forbid_reuse
 def uniform(shape, minval, maxval, seed=None, dtype=mstype.float32):
     """
@@ -374,11 +415,11 @@ def uniform_candidate_sampler(true_classes,
 
     Returns:
         - **sampled_candidates** (Tensor) - The sampled_candidates is independent of the true classes.
-          Shape: :math:`(num\_sampled, )` .
+          shape: :math:`(num\_sampled, )` .
         - **true_expected_count** (Tensor) - The expected counts under the sampling distribution of each
-          of true_classes. Shape: :math:`(batch\_size, num\_true)` .
+          of true_classes. shape: :math:`(batch\_size, num\_true)` .
         - **sampled_expected_count** (Tensor) - The expected counts under the sampling distribution of
-          each of sampled_candidates. Shape: :math:`(num\_sampled, )` .
+          each of sampled_candidates. shape: :math:`(num\_sampled, )` .
 
     Raises:
         TypeError: If neither `num_true` nor `num_sampled` is an int.
@@ -621,57 +662,40 @@ def is_cpu_backend():
     """Check if the CPU is used"""
     return context.get_context('device_target') == 'CPU'
 
-
-@_function_forbid_reuse
-def randperm(n, seed=0, offset=0, dtype=mstype.int64):
+def normal_ext(mean, std, generator=None):
     r"""
-    Generates random permutation of integers from 0 to n-1.
-
-    Returns the tensor with the determined shape inferred by n, the random numbers in it drawn from the data range
-    that a given type can represent.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
+    Generates random numbers according to the standard Normal (or Gaussian) random number distribution.
 
     Args:
-        n (Union[Tensor, int]): The input n Tensor with shape: () or (1,) and with data type of int64.
-            The value of `n` must be greater than zero.
-        seed (int, optional): Random seed. Default: ``0`` . When seed is -1(only negative value), offset is 0,
-            it's determined by time.
-        offset (int, optional): Offset to generate random numbers. Priority is higher than random seed.
-            Default: ``0`` . It must be non-negative.
-        dtype (mindspore.dtype, optional): The type of output.
-            Its value must be one of the following types: int32, int16, int8,
-            uint8, int64, float64, float32, float16. Default: mstype.int64.
+        - **mean** (Union[float, Tensor]) - The mean is a tensor with the mean of each output
+          element's normal distribution.
+        - **std** (Union[float, Tensor]) - The tensor of per-element standard deviations.
+        - **generator** (Generator, optional) - Mindspore generator.
 
     Returns:
-        Tensor. Its shape is specified by the required args `n`. Its type is specified by `dtype`.
-        Otherwise is default.
+        - **output** (Tensor) - With the same type and shape as the 'mean'.
 
     Raises:
-        TypeError: If `dtype` is not allowed.
-        ValueError: If `n` is a negative or 0 element.
-        ValueError: If `seed` is a negative element.
-        ValueError: If `n` is larger than the maximal data of the set dtype.
+        TypeError: If `mean` or `std` is not Union[float, Tensor].
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend``
 
     Examples:
-        >>> from mindspore import ops
-        >>> from mindspore import dtype as mstype
-        >>> n = 4
-        >>> seed = 0
-        >>> offset = 0
-        >>> output = ops.randperm(n, seed, offset, dtype=mstype.int64)
-        >>> print(output)
-        [1 0 2 3]
+        >>> import mindspore
+        >>> import numpy as np
+        >>> import mindspore.ops as ops
+        >>> from mindspore import Tensor
+        >>> mean = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
+        >>> std = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
+        >>> output = ops.normal_ext(mean, std)
+        >>> print(output.shape)
+        (3,)
     """
-    if not isinstance(n, Tensor):
-        n = Tensor(n)
-    randperm_ = RandpermV2(dtype=dtype)
-    randperm_ = _set_prim_op_user_data(randperm_, "random_cache", False)
-    return randperm_(n, seed, offset)
+    if generator is None:
+        generator = default_generator()
+    seed, offset = generator(1)
+    return normal_ext_op(mean, std, seed, offset)
 
 
 @_function_forbid_reuse
@@ -795,8 +819,8 @@ def gamma(shape, alpha, beta, seed=None):
         shape (tuple): The shape of random tensor to be generated.
         alpha (Tensor): The :math:`\alpha` distribution parameter. It should be greater than 0 with float32 data type.
         beta (Tensor): The :math:`\beta` distribution parameter. It should be greater than 0 with float32 data type.
-        seed (int): Seed is used as entropy source for the random number engines to generate
-          pseudo-random numbers, must be non-negative. Default: ``None`` , which will be treated as ``0`` .
+        seed (int, optional): Seed is used as entropy source for the random number engines to generate
+            pseudo-random numbers, must be non-negative. Default: ``None`` , which will be treated as ``0`` .
 
     Returns:
         Tensor. The shape should be equal to the broadcasted shape between the input `shape` and shapes
@@ -924,7 +948,6 @@ def rand(*size, dtype=None, seed=None):
     elif dtype not in mstype.float_type:
         raise ValueError(f"For 'rand', the 'dtype' must be a float type, but got {dtype}.")
     shape = _generate_shapes(size)
-    cast_ = P.Cast()
     seed1, seed2 = _get_seed(seed, 'rand')
     rand_op = P.UniformReal(seed1, seed2)
     rand_op = _set_prim_op_user_data(rand_op, "random_cache", False)
@@ -972,7 +995,6 @@ def rand_like(input, seed=None, *, dtype=None):
     if dtype not in mstype.float_type:
         raise ValueError(f"For 'rand_like', the 'dtype' must be a float type, but got {dtype}.")
     shape = input.shape
-    cast_ = P.Cast()
     seed1, seed2 = _get_seed(seed, 'rand_like')
     rand_op = P.UniformReal(seed1, seed2)
     rand_op = _set_prim_op_user_data(rand_op, "random_cache", False)
@@ -1017,7 +1039,6 @@ def randn(*size, dtype=None, seed=None):
     elif dtype not in mstype.float_type:
         raise ValueError(f"For 'randn', the 'dtype' must be a float type, but got {dtype}.")
     shape = _generate_shapes(size)
-    cast_ = P.Cast()
     seed1, seed2 = _get_seed(seed, 'randn')
     rand_op = P.StandardNormal(seed1, seed2)
     rand_op = _set_prim_op_user_data(rand_op, "random_cache", False)
@@ -1065,7 +1086,6 @@ def randn_like(input, seed=None, *, dtype=None):
     if dtype not in mstype.float_type:
         raise ValueError(f"For 'randn_like', the 'dtype' must be a float type, but got {dtype}.")
     shape = input.shape
-    cast_ = P.Cast()
     seed1, seed2 = _get_seed(seed, 'randn_like')
     rand_op = P.StandardNormal(seed1, seed2)
     rand_op = _set_prim_op_user_data(rand_op, "random_cache", False)
@@ -1119,7 +1139,6 @@ def randint(low, high, size, seed=None, *, dtype=None):
     if not isinstance(high, int) or isinstance(high, bool):
         raise TypeError(f"For 'randint_like', 'high' must be an int, but got {type(high)}.")
     seed1, seed2 = _get_seed(seed, 'randint')
-    cast_ = P.Cast()
     rand_op = P.UniformInt(seed1, seed2)
     rand_op = _set_prim_op_user_data(rand_op, "random_cache", False)
     low_ = Tensor(low, mstype.int32)
@@ -1177,7 +1196,6 @@ def randint_like(input, low, high, seed=None, *, dtype=None):
     seed1, seed2 = _get_seed(seed, 'randint_like')
     rand_op = P.UniformInt(seed1, seed2)
     rand_op = _set_prim_op_user_data(rand_op, "random_cache", False)
-    cast_ = P.Cast()
     low_ = Tensor(low, mstype.int32)
     high_ = Tensor(high, mstype.int32)
     size_ = Tensor(size, mstype.int32)
@@ -1329,35 +1347,30 @@ def multinomial(input, num_samples, replacement=True, seed=None):
         >>> # [[0 0 0 0 0 0 0 0 1 0]
         >>> #  [1 1 1 1 1 0 1 1 1 1]]
     """
-    shape = _get_cache_prim(P.Shape)()
-    reshape = _get_cache_prim(P.Reshape)()
-
     def _check_valid_dim(dim, name):
         if dim not in (1, 2):
             raise ValueError(f"For '{name}', the dimension of inputs must be 1d or 2d, but got {dim}.")
 
-    _check_valid_dim(len(shape(input)), "multinomial")
+    _check_valid_dim(len(shape_(input)), "multinomial")
     seed1, seed2 = _get_seed(seed, "multinomial")
     if not replacement:
-        if shape(input)[-1] < num_samples:
+        if shape_(input)[-1] < num_samples:
             const_utils.raise_value_error(f"For 'multinomial', the 'num_samples' must be less than "
                                           f"the last dimension of input without 'replacement', "
                                           f"but got 'num_samples': {num_samples} and "
                                           f"'replacement': {replacement}")
         n_dist = 1
-        if len(shape(input)) > 1:
-            n_dist = shape(input)[-2]
+        if len(shape_(input)) > 1:
+            n_dist = shape_(input)[-2]
         random_uniform_real = P.UniformReal(seed1, seed2)
         random_cache_op = _set_prim_op_user_data(random_uniform_real, "random_cache", False)
-        random_uniform = random_cache_op((n_dist * shape(input)[-1],))
+        random_uniform = random_cache_op((n_dist * shape_(input)[-1],))
         if n_dist != 1:
-            random_uniform = reshape(random_uniform, (n_dist, shape(input)[-1]))
-        real_div = _get_cache_prim(P.RealDiv)()
-        log = _get_cache_prim(P.Log)()
-        top_k = _get_cache_prim(P.TopK)()
+            random_uniform = reshape_(random_uniform, (n_dist, shape_(input)[-1]))
+
 
-        vals = real_div(log(random_uniform), input + 1e-6)
-        _, indices = top_k(vals, num_samples)
+        vals = real_div_(log_(random_uniform), input + 1e-6)
+        _, indices = top_k_(vals, num_samples)
         return indices
     random_nomial = P.Multinomial(seed1, seed2)
     random_nomial = _set_prim_op_user_data(random_nomial, "random_cache", False)
@@ -1385,9 +1398,9 @@ def _check_param(op_name, param_name, param_value):
 
 
 __all__ = [
-    'standard_laplace', 'random_categorical', 'uniform', 'standard_normal', 'random_gamma',
+    'standard_laplace', 'random_categorical', 'uniform', 'uniform_ext', 'standard_normal', 'random_gamma',
     'uniform_candidate_sampler', 'random_poisson', 'log_uniform_candidate_sampler', 'shuffle', 'choice_with_mask',
-    'normal', 'laplace', 'gamma', 'poisson', 'multinomial', 'rand', 'rand_like', 'randn', 'randn_like', 'randint',
-    'randint_like', 'multinomial_with_replacement', 'randperm'
+    'normal_ext', 'normal', 'laplace', 'gamma', 'poisson', 'multinomial', 'rand', 'rand_like', 'randn', 'randn_like',
+    'randint', 'randint_like', 'multinomial_with_replacement', 'randperm'
 ]
 __all__.sort()

mindspore/ops/function/sparse_unary_func.py

@@ -102,7 +102,7 @@ def coo_cos(x: COOTensor) -> COOTensor:
 
 
 def csr_tan(x: CSRTensor) -> CSRTensor:
-    """
+    r"""
     Computes tangent of `x` element-wise.
 
     .. math::
@@ -139,7 +139,7 @@ def csr_tan(x: CSRTensor) -> CSRTensor:
 
 
 def coo_tan(x: COOTensor) -> COOTensor:
-    """
+    r"""
     Computes tangent of `x` element-wise.
 
     .. math::
@@ -331,10 +331,6 @@ def csr_relu(x: CSRTensor) -> CSRTensor:
 
         ReLU(x) = (x)^+ = \max(0, x)
 
-    Note:
-        In general, this operator is more commonly used. The difference from `ReLuV2` is that the `ReLuV2` will
-        output one more Mask.
-
     Args:
         x (CSRTensor): Input CSRTensor.
 
@@ -376,14 +372,10 @@ def coo_relu(x: COOTensor) -> COOTensor:
 
         ReLU(x) = (x)^+ = \max(0, x)
 
-    Note:
-        In general, this operator is more commonly used. The difference from `ReLuV2` is that the `ReLuV2` will
-        output one more Mask.
-
     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.2/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
 
     Returns:
         COOTensor, has the same shape and dtype as the `x`.
@@ -1034,7 +1026,7 @@ def coo_floor(x: COOTensor) -> COOTensor:
 
 
 def csr_atan(x: CSRTensor) -> CSRTensor:
-    """
+    r"""
     Computes the trigonometric inverse tangent of the input element-wise.
 
     .. math::
@@ -1565,7 +1557,7 @@ def coo_softsign(x: COOTensor) -> COOTensor:
 
 
 def csr_log1p(x: CSRTensor) -> CSRTensor:
-    """
+    r"""
     Returns the natural logarithm of one plus the input CSRTensor element-wise.
 
     .. math::
@@ -1603,7 +1595,7 @@ def csr_log1p(x: CSRTensor) -> CSRTensor:
 
 
 def coo_log1p(x: COOTensor) -> COOTensor:
-    """
+    r"""
     Returns the natural logarithm of one plus the input COOTensor element-wise.
 
     .. math::
@@ -1800,7 +1792,7 @@ def csr_asinh(x: CSRTensor) -> CSRTensor:
         out_i = \sinh^{-1}(input_i)
 
     Args:
-        x (CSRTensor): The input CSRTensor of inverse hyperbolic sine function.
+        x (CSRTensor): The input CSRTensor of inverse hyperbolic sine function, i.e. :math:`input_i`.
 
     Returns:
         CSRTensor, has the same shape and type as `x`.
@@ -1946,7 +1938,8 @@ def csr_acosh(x: CSRTensor) -> CSRTensor:
         out_i = \cosh^{-1}(input_i)
 
     Args:
-        x (CSRTensor): The input CSRTensor of inverse hyperbolic cosine function, its element must be in range [1, inf].
+        x (CSRTensor): The input CSRTensor of inverse hyperbolic cosine function, i.e. :math:`input_i`,
+            its element must be in range [1, inf].
 
     Returns:
         CSRTensor, has the same shape and type as `x`.

mindspore/ops/function/spectral_func.py

@@ -106,7 +106,7 @@ def bartlett_window(window_length, periodic=True, *, dtype=None):
         window_length (Tensor): The size of returned window, with data type int32, int64.
             The input data should be an integer with a value of [0, 1000000].
         periodic (bool, optional): Indicates whether to returns a window to be used as periodic function or
-            a symmetric window. Default: ``True`` .
+            a symmetric window. Default: ``True`` , indicating that the returned window is a periodic function.
 
     Keyword Args:
         dtype (mindspore.dtype, optional): The datatype of returned tensor.

mindspore/ops/function/vmap_func.py

@@ -27,7 +27,7 @@ def vmap(fn, in_axes=0, out_axes=0):
     Vmap is pioneered by Jax and it removes the restriction of batch dimension on the operator, and provides a
     more convenient and unified operator expression. Moreover, it allows users to composite with other functional
     modules such as :func:`mindspore.grad`, to improve the development efficiency, please refer to the
-    `Automatic Vectorization (Vmap) <https://www.mindspore.cn/tutorials/experts/en/r2.2/vmap/vmap.html>`_ tutorial
+    `Automatic Vectorization (Vmap) <https://www.mindspore.cn/tutorials/experts/en/master/vmap/vmap.html>`_ tutorial
     for more detail. In addition, the vectorizing map does not execute loops outside the function, but sinks loops
     into the primitive operations of the function for better performance. When combined with `Graph Kernel Fusion`,
     operational efficiency would be further improved.
@@ -36,12 +36,12 @@ def vmap(fn, in_axes=0, out_axes=0):
         This is an experimental API that is subject to change or deletion.
 
     Note:
-        1. The power of vmap comes from the implementation of VmapRules of primitives. Although we have designed a
-        generalized rule for user custom operators, we can not guarantee that it works well for all operators,
-        unknown exceptions may occur, please be aware the risk of use.
-        2. When calling the random number generation methods within the scope of vmap, the same random number is
-        generated among vector functions each time. If you expect each vector branch to use different random numbers,
-        you need to generate batch random numbers externally in advance and then transfer them to vmap.
+        - The power of vmap comes from the implementation of VmapRules of primitives. Although we have designed a
+          generalized rule for user custom operators, we can not guarantee that it works well for all operators,
+          unknown exceptions may occur, please be aware the risk of use.
+        - When calling the random number generation methods within the scope of vmap, the same random number is
+          generated among vector functions each time. If you expect each vector branch to use different random numbers,
+          you need to generate batch random numbers externally in advance and then transfer them to vmap.
 
     Args:
         fn (Union[Cell, Function, CellList]): Function to be mapped along the parameter axes, which takes at least one
@@ -69,13 +69,13 @@ def vmap(fn, in_axes=0, out_axes=0):
         correspond to those of `fn`, but it adds an extra batch dimension at positions specified by `in_axes` and
         `out_axes`.
 
-    Raises:
-        RuntimeError: If base elements in `in_axes` or `out_axes` are not a None or an integer.
-            If the all base elements in `in_axes` or `out_axes` are None.
-            If `in_axes` is not single integer, and the length of `in_axes` is not equal to the arguments sizes.
-            If `out_axes` is not single integer, and the length of `out_axes` is not equal to the outputs sizes.
-            If the `axis_size` of each arguments in the scope of `vmap` are not equal.
-            If the axis in `in_axes` or `out_axes` is out of bounds.
+    :raise RuntimeError:
+        - If base elements in `in_axes` or `out_axes` are not a None or an integer.
+        - If the all base elements in `in_axes` or `out_axes` are None.
+        - If `in_axes` is not single integer, and the length of `in_axes` is not equal to the arguments sizes.
+        - If `out_axes` is not single integer, and the length of `out_axes` is not equal to the outputs sizes.
+        - If the `axis_size` of each arguments in the scope of `vmap` are not equal.
+        - If the axis in `in_axes` or `out_axes` is out of bounds.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``