mindspore 2.3.0__cp310-cp310-win_amd64.whl → 2.4.1__cp310-cp310-win_amd64.whl

mindspore/ops/function/other_func.py

@@ -14,7 +14,7 @@
 # ============================================================================
 """Defines other operators with functional form."""
 from mindspore.ops import operations as P
-
+from mindspore.ops.auto_generate import rotary_position_embedding
 
 partial_ = P.Partial()
 depend_ = P.Depend()
@@ -109,6 +109,7 @@ def depend(value, expr):
 
 __all__ = [
     'depend',
-    'partial'
+    'partial',
+    'rotary_position_embedding'
 ]
 __all__.sort()

mindspore/ops/function/random_func.py

@@ -30,7 +30,8 @@ from mindspore.common.api import _function_forbid_reuse
 from mindspore.ops.auto_generate import randperm
 from mindspore.common.generator import default_generator
 from mindspore.ops.auto_generate import UniformExt, NormalTensorTensor, \
-    NormalTensorFloat, NormalFloatTensor, NormalFloatFloat, RandExt, RandLikeExt
+    NormalTensorFloat, NormalFloatTensor, NormalFloatFloat, RandExt, RandLikeExt, MultinomialExt, \
+    Randn, RandnLike, RandInt, RandIntLike, RandpermExt
 
 normal_tensor_tensor_op = NormalTensorTensor()
 normal_tensor_float_op = NormalTensorFloat()
@@ -42,9 +43,15 @@ real_div_ = P.RealDiv()
 reshape_ = P.Reshape()
 shape_ = P.Shape()
 top_k_ = P.TopK()
+randperm_ext_ = RandpermExt()
 uniform_ = UniformExt()
 rand_ext_ = RandExt()
 rand_like_ext_ = RandLikeExt()
+multinomial_ext_ = MultinomialExt()
+randn_ = Randn()
+randn_like_ = RandnLike()
+randint_ = RandInt()
+randint_like_ = RandIntLike()
 generator_step_ = Tensor(10, mstype.int64)
 
 
@@ -116,14 +123,18 @@ def standard_laplace(shape, seed=None):
     .. math::
         \text{f}(x) = \frac{1}{2}\exp(-|x|)
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         shape (Union[tuple, Tensor]): The shape of random tensor to be generated. Only constant value is allowed
           when the input type is tuple. And the operator supports dynamic shape only when the input type is Tensor.
         seed (int, optional): Seed is used as entropy source for Random number engines generating pseudo-random numbers.
-          Default: ``None`` , which will be treated as 0.
+          Default: ``None`` .
 
     Returns:
-        Tensor. The shape that the input 'shape' denotes. The dtype is float32.
+        Tensor. The shape that the input `shape` denotes. The dtype is float32.
 
     Raises:
         TypeError: If shape is neither a tuple nor a Tensor.
@@ -153,6 +164,10 @@ def random_categorical(logits, num_sample, seed=0, dtype=mstype.int64):
     r"""
     Generates random samples from a given categorical distribution tensor.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         logits (Tensor): The input tensor. 2-D Tensor with shape :math:`(batch\_size, num\_classes)`.
         num_sample (int):  Number of sample to be drawn. Only constant values is allowed.
@@ -278,7 +293,8 @@ def uniform_ext(tensor, a, b, generator=None):
     """
     if generator is None:
         generator = default_generator
-    seed, offset = generator._step(generator_step_)  # pylint: disable=protected-access
+    seed, offset = generator._step(  # pylint: disable=protected-access
+        generator_step_)
     return uniform_(tensor, a, b, seed, offset)
 
 
@@ -374,6 +390,10 @@ def standard_normal(shape, seed=None):
     .. math::
         f(x)=\frac{1}{\sqrt{2 \pi}} e^{\left(-\frac{x^{2}}{2}\right)}
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         shape (Union[tuple, Tensor]): The shape of random tensor to be generated. Only constant value is allowed
           when the input type is tuple. And the operator supports dynamic shape only when the input type is Tensor.
@@ -419,8 +439,14 @@ def uniform_candidate_sampler(true_classes,
     This function samples a set of classes(sampled_candidates) from [0, range_max-1] based on uniform distribution.
     If unique=True, candidates are drawn without replacement, else unique=False with replacement.
 
+    .. warning::
+        - The Ascend backend does not support the reproducibility of random numbers, so
+          the `seed` parameter has no effect.
+        - The Ascend backend does not support dynamic shape scenarios currently.
+
     Args:
         true_classes (Tensor): A Tensor. The target classes with a Tensor shape of :math:`(batch\_size, num\_true)` .
+            The value range of the elements must be :math:`[0, range\_max)`.
         num_true (int): The number of target classes in each training example.
         num_sampled (int): The number of classes to randomly sample. The sampled_candidates will have a shape
             of num_sampled. If unique=True, num_sampled must be less than or equal to range_max.
@@ -483,11 +509,15 @@ def random_poisson(shape, rate, seed=None, dtype=mstype.float32):
 
         \text{P}(i|μ) = \frac{\exp(-μ)μ^{i}}{i!}
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         shape (Tensor): The shape of random tensor to be sampled from each poisson distribution, 1-D `Tensor` whose
             dtype is mstype.int32 or mstype.int64.
         rate (Tensor): The :math:`μ` parameter the distribution is constructed with.
-            It represents the mean of the distribution
+            It represents the mean of poisson distribution
             and also the variance of the distribution. It should be a `Tensor` whose dtype is mstype.int64,
             mstype.int32, mstype.float64, mstype.float32 or mstype.float16.
         seed (int, optional): Seed is used as entropy source for the random number engines to generate pseudo-random
@@ -582,6 +612,10 @@ def log_uniform_candidate_sampler(true_classes, num_true=1, num_sampled=5, uniqu
 
     Randomly samples a tensor of sampled classes from the range of integers [0, range_max).
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         true_classes (Tensor): The target classes. With data type of int64 and
           shape :math:`(batch\_size, num\_true)` .
@@ -640,12 +674,16 @@ def choice_with_mask(input_x, count=256, seed=None):
     The returned index tensor denotes the index of the nonzero
     sample, the mask tensor denotes which elements in the index tensor are valid.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         input_x (Tensor[bool]): The input tensor.
             The input tensor rank must be greater than or equal to 1 and less than or equal to 5.
         count (int, optional): Number of items expected to get and the number must be greater than 0. Default: ``256`` .
         seed (int, optional): Seed is used as entropy source for Random number engines generating pseudo-random numbers.
-            Default: ``None`` , which will be treated as 0.
+            Default: ``None`` .
 
     Returns:
         Two tensors, the first one is the index tensor and the other one is the mask tensor.
@@ -724,7 +762,8 @@ def normal_ext(mean=0.0, std=1.0, size=None, generator=None):
     """
     if generator is None:
         generator = default_generator
-    seed, offset = generator._step(generator_step_)  # pylint: disable=protected-access
+    seed, offset = generator._step(  # pylint: disable=protected-access
+        generator_step_)
 
     is_mean_tensor = isinstance(mean, Tensor)
     is_std_tensor = isinstance(std, Tensor)
@@ -743,6 +782,10 @@ def normal(shape, mean, stddev, seed=None):
     """
     Generates random numbers according to the Normal (or Gaussian) random number distribution.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         shape (tuple): The shape of random tensor to be generated.
           The format is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
@@ -809,6 +852,10 @@ def laplace(shape, mean, lambda_param, seed=None):
     .. math::
         \text{f}(x;μ,λ) = \frac{1}{2λ}\exp(-\frac{|x-μ|}{λ}),
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         shape (tuple): The shape of random tensor to be generated.
           The format is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
@@ -856,12 +903,16 @@ def gamma(shape, alpha, beta, seed=None):
     r"""
     Generates random numbers according to the Gamma random number distribution.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         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, 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`` .
+            pseudo-random numbers, must be non-negative. Default: ``None`` .
 
     Returns:
         Tensor. The shape should be equal to the broadcasted shape between the input `shape` and shapes
@@ -959,6 +1010,10 @@ def rand(*size, dtype=None, seed=None):
     Returns a new tensor that fills numbers from the uniform distribution over an interval :math:`[0, 1)`
     based on the given shape and dtype.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         size (Union[int, tuple(int), list(int)]): Shape of the new tensor, e.g. :math:`(2, 3)` or :math:`2`.
 
@@ -1003,6 +1058,10 @@ def rand_like(input, seed=None, *, dtype=None):
     Returns a new tensor that fills numbers from the uniform distribution over an interval :math:`[0, 1)`
     based on the given shape and dtype.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         input (Tensor): Input Tensor to specify the output shape and its default dtype.
         seed (int, optional): Random seed, must be greater or equal to 0. Default: ``None`` , and ``0`` will be used.
@@ -1072,13 +1131,14 @@ def rand_ext(*size, generator=None, dtype=None):
         ``Ascend``
 
     Examples:
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> print(ops.function.random_func.rand_ext(2, 3).shape)
         (2, 3)
     """
     if not generator:
         generator = default_generator
-    seed, offset = generator._step(generator_step_)  # pylint: disable=protected-access
+    seed, offset = generator._step(  # pylint: disable=protected-access
+        generator_step_)
     return rand_ext_(size, seed, offset, dtype)
 
 
@@ -1112,16 +1172,184 @@ def rand_like_ext(input, *, dtype=None):
         >>> print(ops.function.random_func.rand_like_ext(a, dtype=ms.float32).shape)
         (2, 3)
     """
-    seed, offset = default_generator._step(generator_step_)  # pylint: disable=protected-access
+    seed, offset = default_generator._step(  # pylint: disable=protected-access
+        generator_step_)
     return rand_like_ext_(input, seed, offset, dtype)
 
 
+@_function_forbid_reuse
+def randn_ext(*size, generator=None, dtype=None):
+    r"""
+    Returns a new tensor filled with numbers from the normal distribution over an interval :math:`[0, 1)`
+    based on the given shape and dtype.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        size (Union[int, tuple(int), list(int)]): Shape of the new tensor, e.g. :math:`(2, 3)` or :math:`2`.
+
+    Keyword Args:
+        generator (:class:`mindspore.Generator`, optional): a pseudorandom number generator.
+            Default: ``None``, uses the default pseudorandom number generator.
+        dtype (:class:`mindspore.dtype`, optional): Designated tensor dtype, it must be float type. If None,
+            `mindspore.float32` will be applied. Default: ``None`` .
+
+    Returns:
+        Tensor, with the designated shape and dtype, filled with random numbers from the normal distribution on
+        the interval :math:`[0, 1)`.
+
+    Raises:
+        ValueError: If `dtype` is not a `mstype.float_type` type.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> from mindspore import ops
+        >>> print(ops.function.random_func.randn_ext(2, 3).shape)
+        (2, 3)
+    """
+    if not generator:
+        generator = default_generator
+    seed, offset = generator._step(  # pylint: disable=protected-access
+        generator_step_)
+    return randn_(size, seed, offset, dtype)
+
+
+@_function_forbid_reuse
+def randn_like_ext(input, *, dtype=None):
+    r"""
+    Returns a new tensor filled with numbers from the normal distribution over an interval :math:`[0, 1)`
+    based on the given dtype and shape of the input tensor.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Input Tensor to specify the output shape and its default dtype.
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): Designated tensor dtype, it must be float type. If None,
+            the same dtype of `input` will be applied. Default: ``None`` .
+
+    Returns:
+        Tensor, with the designated shape and dtype, filled with random numbers from the normal distribution on
+        the interval :math:`[0, 1)`.
+
+    Raises:
+        ValueError: If `dtype` is not a `mstype.float_type` type.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore import Tensor, ops
+        >>> a = Tensor([[2, 3, 4], [1, 2, 3]])
+        >>> print(ops.function.random_func.randn_like_ext(a, dtype=ms.float32).shape)
+        (2, 3)
+    """
+    seed, offset = default_generator._step(  # pylint: disable=protected-access
+        generator_step_)
+    return randn_like_(input, seed, offset, dtype)
+
+
+@_function_forbid_reuse
+def randint_ext(low, high, size, *, generator=None, dtype=None):
+    r"""
+    Returns a new tensor filled with integer numbers from the uniform distribution over an interval :math:`[low, high)`
+    based on the given shape and dtype.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        low (int): the lower bound of the generated random number
+        high (int): the upper bound of the generated random number
+        size (Union[tuple(int), list(int)]): Shape of the new tensor, e.g. :math:`(2, 3)`.
+
+    Keyword Args:
+        generator (:class:`mindspore.Generator`, optional): a pseudorandom number generator.
+            Default: ``None``, uses the default pseudorandom number generator.
+        dtype (:class:`mindspore.dtype`, optional): Designated tensor dtype. If None,
+            `mindspore.int64` will be applied. Default: ``None`` .
+
+    Returns:
+        Tensor, with the designated shape and dtype, filled with random numbers from the uniform distribution on
+        the interval :math:`[low, high)`.
+
+    Raises:
+        TypeError: If `size` is not a tuple.
+        TypeError: If `low` or `high` is not integer.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> from mindspore import ops
+        >>> print(ops.function.random_func.randint_ext(0, 5, (2, 3)).shape)
+        (2, 3)
+    """
+    if not generator:
+        generator = default_generator
+    seed, offset = generator._step(  # pylint: disable=protected-access
+        generator_step_)
+    return randint_(low, high, size, seed, offset, dtype)
+
+
+@_function_forbid_reuse
+def randint_like_ext(input, low, high, *, dtype=None):
+    r"""
+    Returns a new tensor filled with integer numbers from the uniform distribution over an interval :math:`[low, high)`
+    based on the given dtype and shape of the input tensor.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Input Tensor to specify the output shape and its default dtype.
+        low (int): the lower bound of the generated random number
+        high (int): the upper bound of the generated random number
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): Designated tensor dtype. If None,
+            the same dtype of `input` will be applied. Default: ``None`` .
+
+    Returns:
+        Tensor, with the designated shape and dtype, filled with random numbers from the uniform distribution on
+        the interval :math:`[low, high)`.
+
+    Raises:
+        TypeError: If `low` or `high` is not integer.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore import Tensor, ops
+        >>> a = Tensor([[2, 3, 4], [1, 2, 3]])
+        >>> low = 0
+        >>> high = 5
+        >>> print(ops.function.random_func.randint_like_ext(a, low, high, dtype=ms.int32).shape)
+        (2, 3)
+    """
+    seed, offset = default_generator._step(  # pylint: disable=protected-access
+        generator_step_)
+    return randint_like_(input, low, high, seed, offset, dtype)
+
+
 @_function_forbid_reuse
 def randn(*size, dtype=None, seed=None):
     r"""
     Returns a new Tensor with given shape and dtype, filled with a sample (or samples)
     from the standard normal distribution.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         size (Union[int, tuple(int), list(int)]): Shape of the new tensor, e.g., :math:`(2, 3)` or :math:`2`.
 
@@ -1167,6 +1395,10 @@ def randn_like(input, seed=None, *, dtype=None):
     Returns a new Tensor with given shape and dtype, filled with a sample (or samples) from the standard normal
     distribution.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         input (Tensor): Input Tensor to specify the output shape and its default dtype.
         seed (int, optional): Random seed, must be greater or equal to 0. Default: ``None`` , and 0 will be used.
@@ -1215,6 +1447,10 @@ def randint(low, high, size, seed=None, *, dtype=None):
     r"""
     Returns a Tensor whose elements are random integers in the range of [ `low` , `high` ) .
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         low (int): Start value of interval.
         high (int): End value of interval.
@@ -1274,6 +1510,10 @@ def randint_like(input, low, high, seed=None, *, dtype=None):
     Returns a tensor with the same shape as Tensor `input` whose elements are random integers in the range
     of [ `low` , `high` ) .
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         input (Tensor): Input Tensor to specify the output shape and its default dtype.
         low(int): Start value of interval.
@@ -1328,6 +1568,47 @@ def randint_like(input, low, high, seed=None, *, dtype=None):
     return cast_(output, dtype)
 
 
+def randperm_ext(n, *, generator=None, dtype=mstype.int64):
+    r"""
+    Generates random permutation of integers from 0 to n-1.
+
+    .. warning::
+        - This is an experimental API that is subject to change or deletion.
+
+
+    Args:
+        n (Union[Tensor, int]): size of the permutation. int or Tensor with shape: () or (1,) and
+            data type int64. The value of `n` must be greater than zero.
+        generator (:class:`mindspore.Generator`, optional): a pseudorandom number generator.
+            Default: ``None``, uses the default pseudorandom number generator.
+        dtype (mindspore.dtype, optional): The type of output. Default: mstype.int64.
+
+    Returns:
+        Tensor with shape (n,) and type `dtype`.
+
+    Raises:
+        TypeError: If `dtype` is not supported.
+        ValueError: If `n` is a negative or 0 element.
+        ValueError: If `n` is larger than the maximal data of the set dtype.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> from mindspore import ops
+        >>> from mindspore import dtype as mstype
+        >>> n = 4
+        >>> output = ops.randperm_ext(n, dtype=mstype.int64)
+        >>> print(output.shape)
+        (4,)
+    """
+    if not generator:
+        generator = default_generator
+    seed, offset = generator._step(  # pylint: disable=protected-access
+        generator_step_)
+    return randperm_ext_(n, seed, offset, dtype)
+
+
 @_function_forbid_reuse
 def poisson(shape, mean, seed=None):
     r"""
@@ -1418,6 +1699,10 @@ def multinomial(input, num_samples, replacement=True, seed=None):
         but must be non-negative, finite and have a non-zero sum. When using values as weights, it can be understood as
         normalizing the input along the last dimension.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         input (Tensor): The input tensor containing probabilities, must be 1 or 2 dimensions, with
           float32 data type.
@@ -1428,7 +1713,7 @@ def multinomial(input, num_samples, replacement=True, seed=None):
 
     Returns:
         Tensor, has the same rows with input. The number of sampled indices of each row is `num_samples`.
-        The dtype is float32.
+        The dtype is int32.
 
     Raises:
         TypeError: If `input` is not a Tensor whose dtype is not float32.
@@ -1506,6 +1791,111 @@ def multinomial(input, num_samples, replacement=True, seed=None):
     return random_nomial(input, num_samples)
 
 
+@_function_forbid_reuse
+def multinomial_ext(input, num_samples, replacement=False, *, generator=None):
+    r"""
+    Returns a tensor sampled from the multinomial probability distribution located in the corresponding
+    row of the input tensor.
+
+    The polynomial distribution is a probability distribution that generalizes the binomial distribution formula to
+    multiple states. In the polynomial distribution, each event has a fixed probability, and the sum of these
+    probabilities is 1. The purpose of the `mindspore.mint.multinomial` interface is to perform `num_samples` sampling
+    on the input `input`, and the output tensor is the index of the input tensor for each sampling.
+    The values in `input` represent the probability of selecting the corresponding index for each sampling.
+
+    Here is an extreme example for better understanding. Suppose we have an input probability tensor with
+    values `Tensor([90 / 100, 10 / 100, 0], mindspore.float32)`, which means we can sample three indices,
+    namely index 0, index 1, and index 2, with probabilities of 90%, 10%, and 0%, respectively. We perform n samplings,
+    and the resulting sequence is the calculation result of the polynomial distribution, with a length equal to the
+    number of samplings.
+
+    In case 1 of the sample code, we perform two non-replacement samplings (`replacement` is `False`).
+    The calculation result is most likely `[0, 1]`, and less likely `[1, 0]`. Since the probability of selecting
+    index 0 is 90% for each sampling, the first result is most likely to be index 0. Since the probability of selecting
+    index 2 is 0, index 2 cannot appear in the sampling result. Therefore, the second result must be index 1,
+    and the resulting sequence is `[0, 1]`.
+
+    In case 2 of the sample code, we perform 10 replacement samplings (`replacement` is `True`).
+    As expected, about 90% of the sampling results are index 0.
+
+    In case 3 of the sample code, we extend the input to 2 dimensions, and the sampling results
+    in each dimension also match our sampling expectations.
+
+    Note:
+        The rows of input do not need to sum to one (in which case we use the values as weights),
+        but must be non-negative, finite and have a non-zero sum.
+        When using values as weights, it can be understood as normalizing the input along the last dimension.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input tensor containing probabilities, must be 1 or 2 dimensions, with float32 data type.
+        num_samples (int): Number of samples to draw.
+        replacement (bool, optional): Whether to draw with replacement or not. Default: ``False`` .
+
+    Keyword Args:
+        generator (generator, optional): MindSpore generator. Default: ``None``.
+
+    Returns:
+        Tensor, dtype is Int64.
+        If `input` is a vector, out is a vector of size `num_samples`.
+        If `input` is a matrix with m rows, out is an matrix of shape(m * num_samples).
+
+    Raises:
+        TypeError: If `input` is not a Tensor whose dtype is not in float16, float32, float64 or bfloat16.
+        , 或是shape为(1, 1)的Tensor
+        TypeError: If `num_samples` is not an int, a Scalar of int
+            or a Tensor with shape[1,] and only one int element.
+        RuntimeError: If :math:`\text{num_samples} <= 0`.
+        RuntimeError: If `replacement` is False, :math:`\text{num_samples} > shape` of the last dimension of `input`.
+        RuntimeError: If shape of the last dimension of `input` exceeds ``2^24``.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
+        >>> # case 1: The output is random, and the length of the output is the same as num_sample.
+        >>> # replacement is False.
+        >>> input1 = Tensor([90 / 100, 10 / 100, 0], mindspore.float32)
+        >>> input2 = Tensor([90, 10, 0], mindspore.float32)
+        >>> # input1 and input2 have the same meaning.
+        >>> output1 = ops.multinomial_ext(input1, 2)
+        >>> output2 = ops.multinomial_ext(input2, 2)
+        >>> # print(output1)
+        >>> # [0 1]
+        >>> # print(output2)
+        >>> # [0 1]
+        >>> print(len(output1))
+        2
+        >>> print(len(output2))
+        2
+        >>> # case 2: The output is random, and the length of the output is the same as num_sample.
+        >>> # replacement is True.
+        >>> output3 = ops.multinomial_ext(input1, 10, replacement=True)
+        >>> # print(output3)
+        >>> # [0 0 1 0 0 0 0 0 0 0]
+        >>> print(len(output3))
+        10
+        >>> # case 3: The output is random, and the length of the output is the same as num_sample.
+        >>> # replacement is True.
+        >>> # rank is 2
+        >>> input4 = Tensor([[90, 10, 0], [10, 90, 0]], mstype.float32)
+        >>> output4 = ops.multinomial_ext(input4, 10, replacement=True)
+        >>> # print(output4)
+        >>> # [[0 0 0 0 0 0 0 0 1 0]
+        >>> #  [1 1 1 1 1 0 1 1 1 1]]
+    """
+    if generator is None:
+        generator = default_generator
+    seed, offset = generator._step(  # pylint: disable=protected-access
+        generator_step_)
+    return multinomial_ext_(input, num_samples, replacement, seed, offset)
+
+
 def _check_shape(input_shape):
     """Check 'shape' value."""
     if not isinstance(input_shape, tuple):

mindspore/ops/function/reshard_func.py

@@ -35,6 +35,8 @@ def reshard(tensor, layout):
           "sharding_propagation".
         - In the semi-auto parallel mode, the parallel mode will automatically switch to auto
           parallel mode with the search mode be set to "sharding_propagation".
+        - Currently, configuring multi-dimension and multi-copy reshard strategy in
+          mindspore.Layout is not supported.
 
     Args:
         tensor (Tensor): The tensor to be set the sharding strategy.
@@ -55,18 +57,18 @@ def reshard(tensor, layout):
         >>> from mindspore import ops, nn, Tensor, context, Layout
         >>> context.set_context(mode=ms.GRAPH_MODE)
         >>> context.set_auto_parallel_context(parallel_mode=ms.ParallelMode.AUTO_PARALLEL,
-        >>>                                   search_mode="sharding_propagation")
+        ...                                   search_mode="sharding_propagation")
         >>> class Network(nn.Cell):
-        >>>     def __init__(self):
-        >>>         super().__init__()
-        >>>         self.matmul = ops.MatMul()
-        >>>         self.relu = ops.ReLU()
-        >>>     def construct(self, x, layout):
-        >>>         x = self.relu(x)
-        >>>         x_reshard = ops.reshard(x, self.layout)
-        >>>         y = Tensor(np.ones(shape=(128, 128)), dtype=ms.float32)
-        >>>         x = self.matmul(x_reshard, y)
-        >>>         return x
+        ...     def __init__(self):
+        ...         super().__init__()
+        ...         self.matmul = ops.MatMul()
+        ...         self.relu = ops.ReLU()
+        ...     def construct(self, x, layout):
+        ...         x = self.relu(x)
+        ...         x_reshard = ops.reshard(x, layout)
+        ...         y = Tensor(np.ones(shape=(128, 128)), dtype=ms.float32)
+        ...         x = self.matmul(x_reshard, y)
+        ...         return x
         >>>
         >>> layout = Layout((4, 2), ("dp", "mp"))
         >>> input_layout = layout("dp", "mp")

mindspore/ops/function/sparse_unary_func.py

@@ -375,7 +375,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/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Returns:
         COOTensor, has the same shape and dtype as the `x`.