mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

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,9 +25,28 @@ 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.common.generator import default_generator
+from mindspore.ops.auto_generate import UniformExt, NormalTensorTensor, \
+    NormalTensorFloat, NormalFloatTensor, NormalFloatFloat, RandExt, RandLikeExt, MultinomialExt
+
+normal_tensor_tensor_op = NormalTensorTensor()
+normal_tensor_float_op = NormalTensorFloat()
+normal_float_tensor_op = NormalFloatTensor()
+normal_float_float_op = NormalFloatFloat()
+cast_ = P.Cast()
+log_ = P.Log()
+real_div_ = P.RealDiv()
+reshape_ = P.Reshape()
+shape_ = P.Shape()
+top_k_ = P.TopK()
+uniform_ = UniformExt()
+rand_ext_ = RandExt()
+rand_like_ext_ = RandLikeExt()
+multinomial_ext_ = MultinomialExt()
+generator_step_ = Tensor(10, mstype.int64)
 
 
 @constexpr
@@ -77,7 +96,8 @@ def random_gamma(shape, alpha, seed=None):
     """
     seed1, seed2 = _get_seed(seed, "random_gamma")
     random_gamma_op = P.RandomGamma(seed1, seed2)
-    random_gamma_op = _set_prim_op_user_data(random_gamma_op, "random_cache", False)
+    random_gamma_op = _set_prim_op_user_data(
+        random_gamma_op, "random_cache", False)
     output = random_gamma_op(shape, alpha)
     return output
 
@@ -97,14 +117,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.
@@ -124,7 +148,8 @@ def standard_laplace(shape, seed=None):
     """
     seed1, seed2 = _get_seed(seed, "standard_laplace")
     standard_laplace_op = P.StandardLaplace(seed=seed1, seed2=seed2)
-    standard_laplace_op = _set_prim_op_user_data(standard_laplace_op, "random_cache", False)
+    standard_laplace_op = _set_prim_op_user_data(
+        standard_laplace_op, "random_cache", False)
     return standard_laplace_op(shape)
 
 
@@ -133,6 +158,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.
@@ -163,7 +192,8 @@ def random_categorical(logits, num_sample, seed=0, dtype=mstype.int64):
         (10, 8)
     """
     random_categorical_ = P.RandomCategorical(dtype)
-    random_categorical_ = _set_prim_op_user_data(random_categorical_, "random_cache", False)
+    random_categorical_ = _set_prim_op_user_data(
+        random_categorical_, "random_cache", False)
     return random_categorical_(logits, num_sample, seed)
 
 
@@ -223,10 +253,44 @@ def multinomial_with_replacement(x, seed, offset, numsamples, replacement=False)
         offset = Tensor(offset, dtype=mstype.int64)
     multinomial_with_replacement_ = P.MultinomialWithReplacement(numsamples=numsamples,
                                                                  replacement=replacement)
-    multinomial_with_replacement_ = _set_prim_op_user_data(multinomial_with_replacement_, "random_cache", False)
+    multinomial_with_replacement_ = _set_prim_op_user_data(
+        multinomial_with_replacement_, "random_cache", 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 (number): The lower bound of the interval.
+        b (number): 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:
+        >>> import mindspore
+        >>> from mindspore import ops
+        >>> x = ops.ones((4, 2))
+        >>> generator = mindspore.Generator()
+        >>> generator.manual_seed(100)
+        >>> result = ops.function.random_func.uniform_ext(x, 1., 2., generator)
+        >>> print(result.shape)
+        (4, 2)
+    """
+    if generator is None:
+        generator = default_generator
+    seed, offset = generator._step(generator_step_)  # pylint: disable=protected-access
+    return uniform_(tensor, a, b, seed, offset)
+
+
 @_function_forbid_reuse
 def uniform(shape, minval, maxval, seed=None, dtype=mstype.float32):
     """
@@ -284,21 +348,25 @@ def uniform(shape, minval, maxval, seed=None, dtype=mstype.float32):
         (3, 2, 2)
     """
     if not isinstance(minval, Tensor) or not isinstance(maxval, Tensor):
-        raise TypeError(f"For functional operator[uniform], the input[minval] and input[maxval] must be a Tensor.")
+        raise TypeError(
+            f"For functional operator[uniform], the input[minval] and input[maxval] must be a Tensor.")
 
     minval_dtype = F.dtype(minval)
     maxval_dtype = F.dtype(maxval)
-    const_utils.check_type_valid(dtype, [mstype.int32, mstype.float32], 'uniform')
+    const_utils.check_type_valid(
+        dtype, [mstype.int32, mstype.float32], 'uniform')
     const_utils.check_tensors_dtype_same(minval_dtype, dtype, "uniform")
     const_utils.check_tensors_dtype_same(maxval_dtype, dtype, "uniform")
     seed1, seed2 = _get_seed(seed, "uniform")
     if const_utils.is_same_type(dtype, mstype.int32):
         random_uniform = P.UniformInt(seed1, seed2)
-        random_uniform = _set_prim_op_user_data(random_uniform, "random_cache", False)
+        random_uniform = _set_prim_op_user_data(
+            random_uniform, "random_cache", False)
         value = random_uniform(shape, minval, maxval)
     else:
         uniform_real = P.UniformReal(seed1, seed2)
-        uniform_real = _set_prim_op_user_data(uniform_real, "random_cache", False)
+        uniform_real = _set_prim_op_user_data(
+            uniform_real, "random_cache", False)
         uniform_real = uniform_real(shape)
         value = uniform_real * (maxval - minval) + minval
     return value
@@ -315,6 +383,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.
@@ -341,7 +413,8 @@ def standard_normal(shape, seed=None):
     """
     seed1, seed2 = _get_seed(seed, "standard_normal")
     standard_normal_op = P.StandardNormal(seed=seed1, seed2=seed2)
-    standard_normal_op = _set_prim_op_user_data(standard_normal_op, "random_cache", False)
+    standard_normal_op = _set_prim_op_user_data(
+        standard_normal_op, "random_cache", False)
     return standard_normal_op(shape)
 
 
@@ -359,8 +432,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.
@@ -374,11 +453,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.
@@ -408,7 +487,8 @@ def uniform_candidate_sampler(true_classes,
                                            seed=seed,
                                            remove_accidental_hits=remove_accidental_hits)
     sampler_op = _set_prim_op_user_data(sampler_op, "random_cache", False)
-    sampled_candidates, true_expected_count, sampled_expected_count = sampler_op(true_classes)
+    sampled_candidates, true_expected_count, sampled_expected_count = sampler_op(
+        true_classes)
     return sampled_candidates, true_expected_count, sampled_expected_count
 
 
@@ -422,11 +502,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
@@ -472,7 +556,8 @@ def random_poisson(shape, rate, seed=None, dtype=mstype.float32):
     """
     seed1, seed2 = _get_seed(seed, "random_poisson")
     prim_random_poisson = P.RandomPoisson(seed1, seed2, dtype)
-    prim_random_poisson = _set_prim_op_user_data(prim_random_poisson, "random_cache", False)
+    prim_random_poisson = _set_prim_op_user_data(
+        prim_random_poisson, "random_cache", False)
     value = prim_random_poisson(shape, rate)
     return value
 
@@ -507,7 +592,8 @@ def shuffle(x, seed=None):
     """
     seed, seed2 = _get_seed(seed, "shuffle")
     random_shuffle_ = RandomShuffle(seed=seed, seed2=seed2)
-    random_shuffle_ = _set_prim_op_user_data(random_shuffle_, "random_cache", False)
+    random_shuffle_ = _set_prim_op_user_data(
+        random_shuffle_, "random_cache", False)
     output = random_shuffle_(x)
     return output
 
@@ -519,6 +605,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)` .
@@ -561,7 +651,8 @@ def log_uniform_candidate_sampler(true_classes, num_true=1, num_sampled=5, uniqu
 
     """
 
-    sampler = P.LogUniformCandidateSampler(num_true, num_sampled, unique, range_max, seed)
+    sampler = P.LogUniformCandidateSampler(
+        num_true, num_sampled, unique, range_max, seed)
     sampler = _set_prim_op_user_data(sampler, "random_cache", False)
     return sampler(true_classes)
 
@@ -576,12 +667,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.
@@ -600,7 +695,7 @@ def choice_with_mask(input_x, count=256, seed=None):
     Examples:
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> input_x = Tensor(np.ones(shape=[240000, 4]).astype(np.bool))
+        >>> input_x = Tensor(np.ones(shape=[240000, 4]).astype(np.bool_))
         >>> output_y, output_mask = ops.choice_with_mask(input_x)
         >>> result = output_y.shape
         >>> print(result)
@@ -610,8 +705,10 @@ def choice_with_mask(input_x, count=256, seed=None):
         (256,)
     """
     seed1, seed2 = _get_seed(seed, "choice_with_mask")
-    choice_with_mask_ = RandomChoiceWithMask(count=count, seed=seed1, seed2=seed2)
-    choice_with_mask_ = _set_prim_op_user_data(choice_with_mask_, "random_cache", False)
+    choice_with_mask_ = RandomChoiceWithMask(
+        count=count, seed=seed1, seed2=seed2)
+    choice_with_mask_ = _set_prim_op_user_data(
+        choice_with_mask_, "random_cache", False)
     output = choice_with_mask_(input_x)
     return output
 
@@ -622,56 +719,54 @@ def is_cpu_backend():
     return context.get_context('device_target') == 'CPU'
 
 
-@_function_forbid_reuse
-def randperm(n, seed=0, offset=0, dtype=mstype.int64):
+def normal_ext(mean=0.0, std=1.0, size=None, 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], optional): Mean value of each element, the shape of the 'mean' tensor
+            should be the same as that of the 'std' tensor. Default: ``0.0``.
+        std (Union[float, Tensor], optional): Standard deviation for each element, the shape of the 'std' tensor
+            should be the same as that of the 'mean' tensor. The value of std should be greater than or equal to 0.
+            Default: ``1.0``.
+        size (tuple, optional): output size, where 'mean' and 'std' are constants. Default: ``None``.
+        generator (generator, optional): MindSpore generator. Default: ``None``.
 
     Returns:
-        Tensor. Its shape is specified by the required args `n`. Its type is specified by `dtype`.
-        Otherwise is default.
+        Outputs a tensor with the same shape as 'mean',
+        or when 'mean' and 'std' are constants and shape is specified as 'size'.
 
     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:
+        >>> import mindspore
+        >>> import numpy as np
         >>> 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]
+        >>> 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.function.random_func.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._step(generator_step_)  # pylint: disable=protected-access
+
+    is_mean_tensor = isinstance(mean, Tensor)
+    is_std_tensor = isinstance(std, Tensor)
+
+    if is_mean_tensor and is_std_tensor:
+        return normal_tensor_tensor_op(mean, std, seed, offset)
+    if is_mean_tensor and not is_std_tensor:
+        return normal_tensor_float_op(mean, std, seed, offset)
+    if not is_mean_tensor and is_std_tensor:
+        return normal_float_tensor_op(mean, std, seed, offset)
+    return normal_float_float_op(mean, std, size, seed, offset)
 
 
 @_function_forbid_reuse
@@ -679,6 +774,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.
@@ -745,6 +844,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.
@@ -776,7 +879,8 @@ def laplace(shape, mean, lambda_param, seed=None):
     mean_dtype = F.dtype(mean)
     lambda_param_dtype = F.dtype(lambda_param)
     const_utils.check_tensors_dtype_same(mean_dtype, mstype.float32, "laplace")
-    const_utils.check_tensors_dtype_same(lambda_param_dtype, mstype.float32, "laplace")
+    const_utils.check_tensors_dtype_same(
+        lambda_param_dtype, mstype.float32, "laplace")
     seed1, seed2 = _get_seed(seed, "laplace")
     stdlaplace = P.StandardLaplace(seed1, seed2)
     stdlaplace = _set_prim_op_user_data(stdlaplace, "random_cache", False)
@@ -791,12 +895,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): 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`` .
 
     Returns:
         Tensor. The shape should be equal to the broadcasted shape between the input `shape` and shapes
@@ -894,6 +1002,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`.
 
@@ -914,7 +1026,7 @@ def rand(*size, dtype=None, seed=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> print(ops.rand((2,3)))
         [[4.1702199e-01 9.9718481e-01 7.2032452e-01]
          [9.3255734e-01 1.1438108e-04 1.2812445e-01]]
@@ -922,9 +1034,9 @@ def rand(*size, dtype=None, seed=None):
     if dtype is None:
         dtype = mstype.float32
     elif dtype not in mstype.float_type:
-        raise ValueError(f"For 'rand', the 'dtype' must be a float type, but got {dtype}.")
+        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)
@@ -938,6 +1050,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.
@@ -966,13 +1082,14 @@ def rand_like(input, seed=None, *, dtype=None):
          [9.3255734e-01 1.1438108e-04 1.2812445e-01]]
     """
     if not isinstance(input, Tensor):
-        raise TypeError(f"For 'rand_like', the 'input' must be a Tensor, but got {type(input)}")
+        raise TypeError(
+            f"For 'rand_like', the 'input' must be a Tensor, but got {type(input)}")
     if dtype is None:
         dtype = input.dtype
     if dtype not in mstype.float_type:
-        raise ValueError(f"For 'rand_like', the 'dtype' must be a float type, but got {dtype}.")
+        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)
@@ -980,12 +1097,86 @@ def rand_like(input, seed=None, *, dtype=None):
     return cast_(output, dtype)
 
 
+@_function_forbid_reuse
+def rand_ext(*size, generator=None, dtype=None):
+    r"""
+    Returns a new tensor that fills numbers from the uniform distribution over an interval :math:`[0, 1)`
+    based on the given shape and dtype.
+
+    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 uniform 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.rand_ext(2, 3).shape)
+        (2, 3)
+    """
+    if not generator:
+        generator = default_generator
+    seed, offset = generator._step(generator_step_)  # pylint: disable=protected-access
+    return rand_ext_(size, seed, offset, dtype)
+
+
+@_function_forbid_reuse
+def rand_like_ext(input, *, dtype=None):
+    r"""
+    Returns a new tensor that fills numbers from the uniform distribution over an interval :math:`[0, 1)`
+    based on the given dtype and shape of the input tensor.
+
+    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 uniform 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.rand_like_ext(a, dtype=ms.float32).shape)
+        (2, 3)
+    """
+    seed, offset = default_generator._step(generator_step_)  # pylint: disable=protected-access
+    return rand_like_ext_(input, 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`.
 
@@ -1007,7 +1198,7 @@ def randn(*size, dtype=None, seed=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> print(ops.randn((2, 2)))
         [[ 0.30639967 -0.42438635]
          [-0.4287376   1.3054721 ]]
@@ -1015,9 +1206,9 @@ def randn(*size, dtype=None, seed=None):
     if dtype is None:
         dtype = mstype.float32
     elif dtype not in mstype.float_type:
-        raise ValueError(f"For 'randn', the 'dtype' must be a float type, but got {dtype}.")
+        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)
@@ -1031,6 +1222,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.
@@ -1059,13 +1254,14 @@ def randn_like(input, seed=None, *, dtype=None):
          [-0.4287376   1.3054721   0.64747655]]
     """
     if not isinstance(input, Tensor):
-        raise TypeError(f"For 'randn_like', the 'input' must be a Tensor, but got {type(input)}")
+        raise TypeError(
+            f"For 'randn_like', the 'input' must be a Tensor, but got {type(input)}")
     if dtype is None:
         dtype = mstype.float32
     if dtype not in mstype.float_type:
-        raise ValueError(f"For 'randn_like', the 'dtype' must be a float type, but got {dtype}.")
+        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)
@@ -1078,6 +1274,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.
@@ -1103,7 +1303,7 @@ def randint(low, high, size, seed=None, *, dtype=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> print(ops.randint(1, 10, (2,3)))
         [[4 9 7]
          [9 1 2]]
@@ -1111,15 +1311,18 @@ def randint(low, high, size, seed=None, *, dtype=None):
     if dtype is None:
         dtype = mstype.int64
     elif dtype not in mstype.int_type:
-        raise ValueError(f"For 'randint', the 'dtype' must be an int type, but got {dtype}.")
+        raise ValueError(
+            f"For 'randint', the 'dtype' must be an int type, but got {dtype}.")
     if not isinstance(size, tuple):
-        raise ValueError(f"For 'randint', the input 'size' must be a tuple, but got {size}.")
+        raise ValueError(
+            f"For 'randint', the input 'size' must be a tuple, but got {size}.")
     if not isinstance(low, int) or isinstance(low, bool):
-        raise TypeError(f"For 'randint_like', 'low' must be an int, but got {type(low)}.")
+        raise TypeError(
+            f"For 'randint_like', 'low' must be an int, but got {type(low)}.")
     if not isinstance(high, int) or isinstance(high, bool):
-        raise TypeError(f"For 'randint_like', 'high' must be an int, but got {type(high)}.")
+        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)
@@ -1134,6 +1337,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.
@@ -1164,20 +1371,23 @@ def randint_like(input, low, high, seed=None, *, dtype=None):
         [9 1 2]]
     """
     if not isinstance(input, Tensor):
-        raise TypeError(f"For 'randint_like', the 'input' must be a Tensor, but got {type(input)}")
+        raise TypeError(
+            f"For 'randint_like', the 'input' must be a Tensor, but got {type(input)}")
     if dtype is None:
         dtype = input.dtype
     if dtype not in mstype.int_type:
-        raise ValueError(f"For 'randint_like', the 'dtype' must be an int type, but got {dtype}.")
+        raise ValueError(
+            f"For 'randint_like', the 'dtype' must be an int type, but got {dtype}.")
     if not isinstance(low, int) or isinstance(low, bool):
-        raise TypeError(f"For 'randint_like', 'low' must be an int, but got {type(low)}.")
+        raise TypeError(
+            f"For 'randint_like', 'low' must be an int, but got {type(low)}.")
     if not isinstance(high, int) or isinstance(high, bool):
-        raise TypeError(f"For 'randint_like', 'high' must be an int, but got {type(high)}.")
+        raise TypeError(
+            f"For 'randint_like', 'high' must be an int, but got {type(high)}.")
     size = input.shape
     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)
@@ -1234,7 +1444,8 @@ def poisson(shape, mean, seed=None):
     """
     seed1, seed2 = _get_seed(seed, "poisson")
     random_poisson_op = P.Poisson(seed1, seed2)
-    random_poisson_op = _set_prim_op_user_data(random_poisson_op, "random_cache", False)
+    random_poisson_op = _set_prim_op_user_data(
+        random_poisson_op, "random_cache", False)
     value = random_poisson_op(shape, mean)
     return value
 
@@ -1274,6 +1485,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.
@@ -1284,7 +1499,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.
@@ -1329,50 +1544,156 @@ 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}.")
+            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_cache_op = _set_prim_op_user_data(
+            random_uniform_real, "random_cache", False)
+        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)
+    random_nomial = _set_prim_op_user_data(
+        random_nomial, "random_cache", False)
     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(generator_step_)  # pylint: disable=protected-access
+    return multinomial_ext_(input, num_samples, replacement, seed, offset)
+
+
 def _check_shape(input_shape):
     """Check 'shape' value."""
     if not isinstance(input_shape, tuple):
-        const_utils.raise_type_error(f"Type of 'shape' must be tuple, but got: {type(input_shape)}")
+        const_utils.raise_type_error(
+            f"Type of 'shape' must be tuple, but got: {type(input_shape)}")
     for item in input_shape:
         if not isinstance(item, int):
-            const_utils.raise_type_error(f"Elements of 'shape' must be int, but got: {type(item)}")
+            const_utils.raise_type_error(
+                f"Elements of 'shape' must be int, but got: {type(item)}")
         if item < 1:
-            const_utils.raise_value_error(f"Elements of 'shape' must be positive int, but got: {item}")
+            const_utils.raise_value_error(
+                f"Elements of 'shape' must be positive int, but got: {item}")
     return True
 
 
@@ -1387,7 +1708,8 @@ def _check_param(op_name, param_name, param_value):
 __all__ = [
     'standard_laplace', 'random_categorical', 'uniform', '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', 'laplace', 'gamma', 'poisson', 'multinomial', 'rand', 'rand_like',
+    'randn', 'randn_like',
+    'randint', 'randint_like', 'multinomial_with_replacement', 'randperm'
 ]
 __all__.sort()