mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/ops/function/random_func.py

@@ -15,6 +15,7 @@
 """Defines parameter operators with functional form."""
 
 from __future__ import absolute_import
+import numpy as np
 
 from mindspore import context
 from mindspore.ops import operations as P
@@ -29,6 +30,12 @@ from mindspore.ops._primitive_cache import _get_cache_prim
 from mindspore.common.api import _function_forbid_reuse
 
 
+@constexpr
+def _set_prim_op_user_data(prim, key, value):
+    prim.add_prim_attr(key, value)
+    return prim
+
+
 @_function_forbid_reuse
 def random_gamma(shape, alpha, seed=None):
     r"""
@@ -41,7 +48,7 @@ def random_gamma(shape, alpha, seed=None):
         alpha (Tensor): The :math:`\alpha` distribution parameter.
             A Tensor. Must be one of the following types: half, float32, float64.
         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`` , which will be treated as 0.
 
     Returns:
         Tensor. The shape should be equal to the concat shape between the input `shape` and the broadcast
@@ -69,7 +76,8 @@ def random_gamma(shape, alpha, seed=None):
         (7, 5, 2)
     """
     seed1, seed2 = _get_seed(seed, "random_gamma")
-    random_gamma_op = _get_cache_prim(P.RandomGamma)(seed1, seed2)
+    random_gamma_op = P.RandomGamma(seed1, seed2)
+    random_gamma_op = _set_prim_op_user_data(random_gamma_op, "random_cache", False)
     output = random_gamma_op(shape, alpha)
     return output
 
@@ -93,7 +101,7 @@ def standard_laplace(shape, seed=None):
         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`` , which will be treated as 0.
 
     Returns:
         Tensor. The shape that the input 'shape' denotes. The dtype is float32.
@@ -115,7 +123,8 @@ def standard_laplace(shape, seed=None):
         (4, 4)
     """
     seed1, seed2 = _get_seed(seed, "standard_laplace")
-    standard_laplace_op = _get_cache_prim(P.StandardLaplace)(seed=seed1, seed2=seed2)
+    standard_laplace_op = P.StandardLaplace(seed=seed1, seed2=seed2)
+    standard_laplace_op = _set_prim_op_user_data(standard_laplace_op, "random_cache", False)
     return standard_laplace_op(shape)
 
 
@@ -127,9 +136,9 @@ def random_categorical(logits, num_sample, seed=0, dtype=mstype.int64):
     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.
-        seed (int):  Random seed. Only constant values is allowed. Default: 0.
+        seed (int):  Random seed. Only constant values is allowed. Default: ``0`` .
         dtype (mindspore.dtype): The type of output. Its value must be one of mindspore.int16,
-            mindspore.int32 and mindspore.int64. Default: mindspore.int64.
+            mindspore.int32 and mindspore.int64. Default: ``mstype.int64`` .
 
     Returns:
         Tensor, The output Tensor with shape :math:`(batch\_size, num\_samples)`.
@@ -154,6 +163,7 @@ 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)
     return random_categorical_(logits, num_sample, seed)
 
 
@@ -175,7 +185,7 @@ def multinomial_with_replacement(x, seed, offset, numsamples, replacement=False)
           generator is seeded by a random seed. Otherwise, it is seeded by the given seed.
         offset (int): Offset used to avoid seed collision.
         numsamples (int): the number of samples to draw.
-        replacement (bool, optional): Whether to draw with replacement or not. Default: False.
+        replacement (bool, optional): Whether to draw with replacement or not. Default: ``False`` .
 
     Returns:
         Tensor with the same rows as `x`, each row has `numsamples` sampled indices.
@@ -194,6 +204,8 @@ def multinomial_with_replacement(x, seed, offset, numsamples, replacement=False)
         ``CPU``
 
     Examples:
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> x = Tensor([[0., 9., 4., 0.]], mstype.float32)
         >>> output = ops.multinomial_with_replacement(x, 2, 5, 2, True)
         >>> print(output)
@@ -201,16 +213,17 @@ def multinomial_with_replacement(x, seed, offset, numsamples, replacement=False)
     """
     if not isinstance(seed, Tensor):
         if not isinstance(seed, int):
-            raise TypeError("For multinomial_with_replacement,",
-                            "the input[seed] must be int, but got {}.".format(type(seed)))
+            raise TypeError(f"For multinomial_with_replacement,",
+                            f"the input[seed] must be int, but got {type(seed)}.")
         seed = Tensor(seed, dtype=mstype.int64)
     if not isinstance(offset, Tensor):
         if not isinstance(offset, int):
-            raise TypeError("For multinomial_with_replacement,",
-                            "the input[offset] must be int, but got {}.".format(type(offset)))
+            raise TypeError(f"For multinomial_with_replacement,",
+                            f"the input[offset] must be int, but got {type(offset)}.")
         offset = Tensor(offset, dtype=mstype.int64)
-    multinomial_with_replacement_ = _get_cache_prim(P.MultinomialWithReplacement)(numsamples=numsamples,
-                                                                                  replacement=replacement)
+    multinomial_with_replacement_ = P.MultinomialWithReplacement(numsamples=numsamples,
+                                                                 replacement=replacement)
+    multinomial_with_replacement_ = _set_prim_op_user_data(multinomial_with_replacement_, "random_cache", False)
     return multinomial_with_replacement_(x, seed, offset)
 
 
@@ -231,10 +244,10 @@ def uniform(shape, minval, maxval, seed=None, dtype=mstype.float32):
           It defines the maximum possible generated value, with int32 or float32 data type.
           If dtype is int32, only one number is allowed.
         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.
+          must be non-negative. Default: ``None`` , which will be treated as 0.
         dtype (mindspore.dtype): Type of the Uniform distribution. If it is int32, it generates numbers from discrete
           uniform distribution; if it is float32, it generates numbers from continuous uniform distribution. It only
-          supports these two data types. Default: mindspore.float32.
+          supports these two data types. Default: mstype.float32.
 
     Returns:
         Tensor. The shape should be equal to the broadcasted shape between the input `shape` and shapes
@@ -281,11 +294,13 @@ def uniform(shape, minval, maxval, seed=None, dtype=mstype.float32):
     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)
         value = random_uniform(shape, minval, maxval)
     else:
         uniform_real = P.UniformReal(seed1, seed2)
-        random_uniform = uniform_real(shape)
-        value = random_uniform * (maxval - minval) + minval
+        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
 
 
@@ -304,7 +319,7 @@ def standard_normal(shape, seed=None):
         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`` , which will be treated as 0.
 
     Returns:
         Tensor. The shape that the input 'shape' denotes. The dtype is float32.
@@ -325,7 +340,8 @@ def standard_normal(shape, seed=None):
         (4, 4)
     """
     seed1, seed2 = _get_seed(seed, "standard_normal")
-    standard_normal_op = _get_cache_prim(P.StandardNormal)(seed=seed1, seed2=seed2)
+    standard_normal_op = P.StandardNormal(seed=seed1, seed2=seed2)
+    standard_normal_op = _set_prim_op_user_data(standard_normal_op, "random_cache", False)
     return standard_normal_op(shape)
 
 
@@ -344,23 +360,25 @@ def uniform_candidate_sampler(true_classes,
     If unique=True, candidates are drawn without replacement, else unique=False with replacement.
 
     Args:
-        true_classes (Tensor): A Tensor. The target classes with a Tensor shape of :math:`(batch_size, num_true)` .
+        true_classes (Tensor): A Tensor. The target classes with a Tensor shape of :math:`(batch\_size, num\_true)` .
         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.
         unique (bool): Whether all sampled classes in a batch are unique.
         range_max (int): The number of possible classes, must be positive.
         seed (int): Used for random number generation, must be non-negative. If seed has a value of 0,
-            the seed will be replaced with a randomly generated value. Default: 0.
-        remove_accidental_hits (bool): Whether accidental hit is removed. Default: False.
+            the seed will be replaced with a randomly generated value. Default: ``0`` .
+        remove_accidental_hits (bool): Whether accidental hit is removed.
+            Accidental hit is when one of the true classes matches one of the sample classes.
+            Set ``True`` to remove which accidentally sampling the true class as sample class. Default: ``False`` .
 
     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.
@@ -372,6 +390,8 @@ def uniform_candidate_sampler(true_classes,
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> data = Tensor(np.array([[1], [3], [4], [6], [3]], dtype=np.int64))
         >>> output1, output2, output3 = ops.uniform_candidate_sampler(data, 1, 3, False, 4, 1)
         >>> print(output1.shape)
@@ -381,12 +401,13 @@ def uniform_candidate_sampler(true_classes,
         >>> print(output3.shape)
         (3,)
     """
-    sampler_op = _get_cache_prim(P.UniformCandidateSampler)(num_true,
-                                                            num_sampled,
-                                                            unique,
-                                                            range_max,
-                                                            seed=seed,
-                                                            remove_accidental_hits=remove_accidental_hits)
+    sampler_op = P.UniformCandidateSampler(num_true,
+                                           num_sampled,
+                                           unique,
+                                           range_max,
+                                           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)
     return sampled_candidates, true_expected_count, sampled_expected_count
 
@@ -403,15 +424,15 @@ def random_poisson(shape, rate, seed=None, dtype=mstype.float32):
 
     Args:
         shape (Tensor): The shape of random tensor to be sampled from each poisson distribution, 1-D `Tensor` whose
-          dtype is mindspore.dtype.int32 or mindspore.dtype.int64.
+            dtype is mstype.int32 or mstype.int64.
         rate (Tensor): The :math:`μ` parameter the distribution is constructed with.
-          It represents the mean of the distribution
-          and also the variance of the distribution. It should be a `Tensor` whose dtype is mindspore.dtype.int64,
-          mindspore.dtype.int32, mindspore.dtype.float64, mindspore.dtype.float32 or mindspore.dtype.float16.
+            It represents the mean of the 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
-          numbers and must be non-negative. Default: None, which will be treated as 0.
-        dtype (mindspore.dtype): The data type of output: mindspore.dtype.int64, mindspore.dtype.int32,
-          mindspore.dtype.float64, mindspore.dtype.float32 or mindspore.dtype.float16. Default: mindspore.dtype.float32.
+            numbers and must be non-negative. Default: ``None`` , which will be treated as 0.
+        dtype (mindspore.dtype): The data type of output: ``mstype.int64``, ``mstype.int32``,
+            ``mstype.float64``, ``mstype.float32`` or ``mstype.float16``. Default: ``mstype.float32``.
 
     Returns:
         A Tensor whose shape is `mindspore.concat(['shape', mindspore.shape('rate')], axis=0)` and data type is equal to
@@ -419,14 +440,14 @@ def random_poisson(shape, rate, seed=None, dtype=mstype.float32):
 
     Raises:
         TypeError: If `shape` is not a Tensor.
-        TypeError: If datatype of `shape` is not mindspore.dtype.int64 nor mindspore.dtype.int32.
+        TypeError: If datatype of `shape` is not mstype.int64 nor mstype.int32.
         ValueError: If shape of `shape` is not 1-D.
         TypeError: If `rate` is not a Tensor nor a scalar.
-        TypeError: If datatype of `rate` is not in [mindspore.dtype.int64, mindspore.dtype.int32,
-          mindspore.dtype.float64, mindspore.dtype.float32 or mindspore.dtype.float16].
+        TypeError: If datatype of `rate` is not in [mstype.int64, mstype.int32,
+            mstype.float64, mstype.float32 or mstype.float16].
         TypeError: If `seed` is not a non-negtive int.
-        TypeError: If `dtype` is not in [mindspore.dtype.int64, mindspore.dtype.int32, mindspore.dtype.float64,
-          mindspore.dtype.float32 nor mindspore.dtype.float16].
+        TypeError: If `dtype` is not in [mstype.int64, mstype.int32, mstype.float64,
+            mstype.float32 nor mstype.float16].
         ValueError: If any element of input `shape` tensor is not positive.
 
     Supported Platforms:
@@ -450,7 +471,8 @@ def random_poisson(shape, rate, seed=None, dtype=mstype.float32):
         (2, 2) Int64
     """
     seed1, seed2 = _get_seed(seed, "random_poisson")
-    prim_random_poisson = P.random_ops.RandomPoisson(seed1, seed2, dtype)
+    prim_random_poisson = P.RandomPoisson(seed1, seed2, dtype)
+    prim_random_poisson = _set_prim_op_user_data(prim_random_poisson, "random_cache", False)
     value = prim_random_poisson(shape, rate)
     return value
 
@@ -463,7 +485,7 @@ def shuffle(x, seed=None):
     Args:
         x (Tensor): The Tensor need be shuffled.
         seed (int, optional): Random seed used for random number generation, must be non-negative. If `seed` is 0,
-            which will be replaced with a randomly generated value. Default: None, which will be treated as 0.
+            which will be replaced with a randomly generated value. Default: ``None`` , which will be treated as 0.
 
     Returns:
         Tensor. The shape and type are the same as the input `x`.
@@ -475,13 +497,17 @@ def shuffle(x, seed=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> x = Tensor(np.array([1, 2, 3, 4]), mstype.float32)
         >>> output = ops.shuffle(x, seed=1)
         >>> print(output)
-        (3. 4. 2. 1.)
+        [3. 4. 2. 1.]
     """
     seed, seed2 = _get_seed(seed, "shuffle")
-    random_shuffle_ = _get_cache_prim(RandomShuffle)(seed=seed, seed2=seed2)
+    random_shuffle_ = RandomShuffle(seed=seed, seed2=seed2)
+    random_shuffle_ = _set_prim_op_user_data(random_shuffle_, "random_cache", False)
     output = random_shuffle_(x)
     return output
 
@@ -496,13 +522,13 @@ def log_uniform_candidate_sampler(true_classes, num_true=1, num_sampled=5, uniqu
     Args:
         true_classes (Tensor): The target classes. With data type of int64 and
           shape :math:`(batch\_size, num\_true)` .
-        num_true (int): The number of target classes per training example. Default: 1.
-        num_sampled (int): The number of classes to randomly sample. Default: 5.
-        unique (bool): Determines whether sample with rejection. If `unique` is True,
-          all sampled classes in a batch are unique. Default: True.
-        range_max (int): The number of possible classes. When `unique` is True,
-          `range_max` must be greater than or equal to `num_sampled`. Default: 5.
-        seed (int): Random seed, must be non-negative. Default: 0.
+        num_true (int): The number of target classes per training example. Default: ``1`` .
+        num_sampled (int): The number of classes to randomly sample. Default: ``5`` .
+        unique (bool): Determines whether sample with rejection. If `unique` is ``True`` ,
+          all sampled classes in a batch are unique. Default: ``True`` .
+        range_max (int): The number of possible classes. When `unique` is ``True`` ,
+          `range_max` must be greater than or equal to `num_sampled`. Default: ``5`` .
+        seed (int): Random seed, must be non-negative. Default: ``0`` .
 
     Returns:
         Tuple of 3 Tensors.
@@ -535,7 +561,8 @@ def log_uniform_candidate_sampler(true_classes, num_true=1, num_sampled=5, uniqu
 
     """
 
-    sampler = _get_cache_prim(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)
 
 
@@ -552,9 +579,9 @@ def choice_with_mask(input_x, count=256, seed=None):
     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.
+        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`` , which will be treated as 0.
 
     Returns:
         Two tensors, the first one is the index tensor and the other one is the mask tensor.
@@ -571,6 +598,8 @@ def choice_with_mask(input_x, count=256, seed=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> 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
@@ -581,7 +610,8 @@ def choice_with_mask(input_x, count=256, seed=None):
         (256,)
     """
     seed1, seed2 = _get_seed(seed, "choice_with_mask")
-    choice_with_mask_ = _get_cache_prim(RandomChoiceWithMask)(count=count, seed=seed1, seed2=seed2)
+    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
 
@@ -600,19 +630,23 @@ def randperm(n, seed=0, offset=0, dtype=mstype.int64):
     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.
+
     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,
+        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.
+            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: int64.
+            uint8, int64, float64, float32, float16. Default: mstype.int64.
 
     Returns:
-        Tensor. Its shape is specified by the required args `n`. Its type is spcified by `dtype`. Otherwise is default.
+        Tensor. Its shape is specified by the required args `n`. Its type is specified by `dtype`.
+        Otherwise is default.
 
     Raises:
         TypeError: If `dtype` is not allowed.
@@ -624,6 +658,8 @@ def randperm(n, seed=0, offset=0, dtype=mstype.int64):
         ``CPU``
 
     Examples:
+        >>> from mindspore import ops
+        >>> from mindspore import dtype as mstype
         >>> n = 4
         >>> seed = 0
         >>> offset = 0
@@ -633,7 +669,8 @@ def randperm(n, seed=0, offset=0, dtype=mstype.int64):
     """
     if not isinstance(n, Tensor):
         n = Tensor(n)
-    randperm_ = _get_cache_prim(RandpermV2)(dtype=dtype)
+    randperm_ = RandpermV2(dtype=dtype)
+    randperm_ = _set_prim_op_user_data(randperm_, "random_cache", False)
     return randperm_(n, seed, offset)
 
 
@@ -645,17 +682,15 @@ def normal(shape, mean, stddev, seed=None):
     Args:
         shape (tuple): The shape of random tensor to be generated.
           The format is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
-        mean (Union[Tensor, int, float]): The mean μ distribution parameter, which specifies the location of the peak,
-          with data type in [int8, int16, int32, int64, float16, float32].
-        stddev (Union[Tensor, int, float]): The deviation σ distribution parameter. It should be greater than 0,
-          with data type in [int8, int16, int32, int64, float16, float32].
+        mean (Union[Tensor, int, float]): The mean μ distribution parameter, which specifies the location of the peak.
+        stddev (Union[Tensor, int, float]): The deviation σ distribution parameter. It should be greater than 0.
         seed (int): Seed is used as entropy source for the Random number engines to generate pseudo-random numbers.
-          The value must be non-negative. Default: None, which will be treated as 0.
+          The value 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
         of `mean` and `stddev`.
-        The dtype is float32.
+        The dtype is [float32, float64].
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -692,12 +727,9 @@ def normal(shape, mean, stddev, seed=None):
         mean = Tensor(mean)
     if not isinstance(stddev, Tensor):
         stddev = Tensor(stddev)
-    mean_dtype = F.dtype(mean)
-    stddev_dtype = F.dtype(stddev)
-    const_utils.check_type_valid(mean_dtype, mstype.int_type + (mstype.float16, mstype.float32), 'normal')
-    const_utils.check_type_valid(stddev_dtype, mstype.int_type + (mstype.float16, mstype.float32), 'normal')
     seed1, seed2 = _get_seed(seed, "normal")
     stdnormal = P.StandardNormal(seed1, seed2)
+    stdnormal = _set_prim_op_user_data(stdnormal, "random_cache", False)
     _check_shape(shape)
     random_normal = stdnormal(shape)
     value = random_normal * stddev + mean
@@ -721,7 +753,7 @@ def laplace(shape, mean, lambda_param, seed=None):
         lambda_param (Tensor): The parameter used for controlling the variance of this random distribution. The
           variance of Laplace distribution is equal to twice the square of lambda_param. With float32 data type.
         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`` , which will be treated as 0.
 
     Returns:
         Tensor. The shape should be the broadcasted shape of input `shape` and shapes of `mean` and `lambda_param`.
@@ -747,6 +779,7 @@ def laplace(shape, mean, lambda_param, seed=None):
     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)
     _check_shape(shape)
     rnd = stdlaplace(shape)
     value = rnd * lambda_param + mean
@@ -763,7 +796,7 @@ def gamma(shape, alpha, beta, seed=None):
         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.
+          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
@@ -804,30 +837,29 @@ def gamma(shape, alpha, beta, seed=None):
         >>> alpha = Tensor(np.array([[3, 4], [5, 6]]), mindspore.float32)
         >>> beta = Tensor(np.array([1.0, 2]), mindspore.float32)
         >>> output = ops.gamma(shape, alpha, beta, seed=5)
-        >>> result = output.shape
         >>> print(output)
-        [[[ 2.2132034  5.8855834]]
-         [ 3.3981476  7.5805717]
-        [[ 3.3981476  7.5805717]]
-         [ 3.7190282 19.941492]
-        [[ 2.9512358  2.5969937]]
-         [ 3.786061   5.160872 ]]]
+        [[[ 2.2132034  5.8855834]
+          [ 3.8825176  8.6066265]]
+         [[ 3.3981476  7.5805717]
+          [ 3.7190282 19.941492 ]]
+         [[ 2.9512358  2.5969937]
+          [ 3.786061   5.160872 ]]]
         >>> # case 4: beta_shape is (2, 1), the output is different.
         >>> shape = (3, 1, 2)
         >>> alpha = Tensor(np.array([[3, 4], [5, 6]]), mindspore.float32)
         >>> beta = Tensor(np.array([[1.0], [2.0]]), mindspore.float32)
         >>> output = ops.gamma(shape, alpha, beta, seed=5)
-        >>> result = output.shape
         >>> print(output)
-        [[[ 5.6085486  7.8280783]]
-         [ 15.97684  16.116285]
-        [[ 1.8347423  1.713663]]
-         [ 3.2434065 15.667398]
-        [[ 4.2922077  7.3365674]]
+        [[[ 5.6085486  7.8280783]
+         [ 15.97684  16.116285]]
+        [[ 1.8347423  1.713663]
+         [ 3.2434065 15.667398]]
+        [[ 4.2922077  7.3365674]
          [ 5.3876944  13.159832 ]]]
     """
     seed1, seed2 = _get_seed(seed, "gamma")
     gamma_v = P.Gamma(seed1, seed2)
+    gamma_v = _set_prim_op_user_data(gamma_v, "random_cache", False)
     value = gamma_v(shape, alpha, beta)
     return value
 
@@ -845,13 +877,13 @@ def _generate_shapes(shape):
         elif isinstance(shape[0], tuple):
             size = shape[0]
         else:
-            raise TypeError("If the length of the argument 'shape' is 1, the type of the argument 'shape' must be "
-                            "one of ['int', 'list', 'tuple'], but got ", shape[0])
+            raise TypeError(f"If the length of the argument 'shape' is 1, the type of the argument 'shape' must be "
+                            f"one of ['int', 'list', 'tuple'], but got {shape[0]}.")
     else:
         for value in shape:
             if not isinstance(value, int):
-                raise TypeError("If the length of the argument 'shape' is > 1, the type of the argument 'shape' must "
-                                "all be int, but got ", value)
+                raise TypeError(f"If the length of the argument 'shape' is > 1, the type of the argument 'shape' must "
+                                f"all be int, but got {value}.")
         size = shape
     return size
 
@@ -867,8 +899,8 @@ def rand(*size, dtype=None, seed=None):
 
     Keyword Args:
         dtype (:class:`mindspore.dtype`, optional): Designated tensor dtype, it must be float type. If None,
-            `mindspore.float32` will be applied. Default: None.
-        seed (int, optional): Random seed, must be greater or equal to 0. Default: None, and 0 will be used.
+            `mindspore.float32` will be applied. Default: ``None`` .
+        seed (int, optional): Random seed, must be greater or equal to 0. Default: ``None`` , and ``0`` will be used.
 
     Returns:
         Tensor, with the designated shape and dtype, filled with random numbers from the uniform distribution on
@@ -895,6 +927,7 @@ def rand(*size, dtype=None, seed=None):
     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)
     output = rand_op(shape)
     return cast_(output, dtype)
 
@@ -907,11 +940,11 @@ def rand_like(input, seed=None, *, dtype=None):
 
     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.
+        seed (int, optional): Random seed, must be greater or equal to 0. Default: ``None`` , and ``0`` will be used.
 
     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.
+            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
@@ -932,15 +965,17 @@ def rand_like(input, seed=None, *, dtype=None):
         [[4.1702199e-01 9.9718481e-01 7.2032452e-01]
          [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)}")
     if dtype is None:
         dtype = input.dtype
-    elif dtype not in mstype.float_type:
+    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)
     output = rand_op(shape)
     return cast_(output, dtype)
 
@@ -956,8 +991,8 @@ def randn(*size, dtype=None, seed=None):
 
     Keyword Args:
         dtype (:class:`mindspore.dtype`, optional): Designated tensor dtype, it must be float type. If None,
-            `mindspore.float32` will be used. Default: None.
-        seed (int, optional): Random seed, must be greater or equal to 0. Default: None, and 0 will be used.
+            `mindspore.float32` will be used. Default: ``None`` .
+        seed (int, optional): Random seed, must be greater or equal to 0. Default: ``None`` , and 0 will be used.
 
     Returns:
         Tensor, with the designated shape and dtype, filled with a sample (or samples) from the
@@ -985,6 +1020,7 @@ def randn(*size, dtype=None, seed=None):
     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)
     output = rand_op(shape)
     return cast_(output, dtype)
 
@@ -997,11 +1033,11 @@ def randn_like(input, seed=None, *, dtype=None):
 
     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.
+        seed (int, optional): Random seed, must be greater or equal to 0. Default: ``None`` , and 0 will be used.
 
     Keyword Args:
         dtype (:class:`mindspore.dtype`, optional): Designated tensor dtype, it must be float type. If None,
-            `mindspore.float32` will be used. Default: None.
+            `mindspore.float32` will be used. Default: ``None`` .
 
     Returns:
         Tensor, with the designated shape and dtype, filled with a sample (or samples) from the
@@ -1022,14 +1058,17 @@ def randn_like(input, seed=None, *, dtype=None):
         [[ 0.30639967 -0.42438635 -0.20454668]
          [-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)}")
     if dtype is None:
-        dtype = input.dtype
-    elif dtype not in mstype.float_type:
+        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}.")
     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)
     output = rand_op(shape)
     return cast_(output, dtype)
 
@@ -1043,11 +1082,11 @@ def randint(low, high, size, seed=None, *, dtype=None):
         low (int): Start value of interval.
         high (int): End value of interval.
         size (tuple): Shape of the new tensor.
-        seed (int, optional): Random seed, must be greater or equal to 0. Default: None, and 0 will be used.
+        seed (int, optional): Random seed, must be greater or equal to 0. Default: ``None`` , and ``0`` will be used.
 
     Keyword Args:
-        dtype (:class:`mindspore.dtype`, optional): Designated tensor dtype, it must be int type. If None,
-            `mindspore.int64` will be used. Default: None.
+        dtype (:class:`mindspore.dtype`, optional): Designated tensor dtype, it must be int type. If ``None`` ,
+            `mindspore.int64` will be used. Default: ``None`` .
 
     Returns:
         Tensor, with the designated shape and dtype, filled with random integers from low (inclusive)
@@ -1075,11 +1114,14 @@ def randint(low, high, size, seed=None, *, dtype=None):
         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}.")
-    if not isinstance(low, int) or not isinstance(high, int):
-        raise TypeError(f"For 'randint', 'low' and 'high' must be an int, but got {type(low)} and {type(high)}.")
+    if not isinstance(low, int) or isinstance(low, bool):
+        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)}.")
     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)
     high_ = Tensor(high, mstype.int32)
     output = rand_op(size, low_, high_)
@@ -1096,11 +1138,11 @@ def randint_like(input, low, high, seed=None, *, dtype=None):
         input (Tensor): Input Tensor to specify the output shape and its default dtype.
         low(int): Start value of interval.
         high(int): End value of interval.
-        seed (int, optional): Random seed, must be greater or equal to 0. Default: None, and 0 will be used.
+        seed (int, optional): Random seed, must be greater or equal to 0. Default: ``None`` , and 0 will be used.
 
     Keyword Args:
-        dtype (:class:`mindspore.dtype`, optional): Designated tensor dtype, it must be int type. If None,
-            `mindspore.int64` will be used. Default is `mindspore.int64`.
+        dtype (:class:`mindspore.dtype`, optional): Designated tensor dtype, it must be int type. If ``None`` ,
+            the same dtype of `input` will be applied. Default: ``None`` .
 
     Returns:
         Tensor, with the designated shape and dtype, filled with random integers from low (inclusive)
@@ -1121,15 +1163,20 @@ def randint_like(input, low, high, seed=None, *, dtype=None):
        [[4 9 7]
         [9 1 2]]
     """
+    if not isinstance(input, Tensor):
+        raise TypeError(f"For 'randint_like', the 'input' must be a Tensor, but got {type(input)}")
     if dtype is None:
         dtype = input.dtype
-    elif dtype not in mstype.int_type:
+    if dtype not in mstype.int_type:
         raise ValueError(f"For 'randint_like', the 'dtype' must be an int type, but got {dtype}.")
-    if not isinstance(low, int) or not isinstance(high, int):
-        raise TypeError(f"For 'randint_like', 'low' and 'high' must be an int, but got {type(low)} and {type(high)}.")
+    if not isinstance(low, int) or isinstance(low, bool):
+        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)}.")
     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)
@@ -1152,7 +1199,7 @@ def poisson(shape, mean, seed=None):
           The format is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
         mean (Tensor): The mean μ 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
-          and must be non-negative. Default: None, which will be treated as 0.
+          and 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 of `mean`.
@@ -1186,6 +1233,7 @@ 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)
     value = random_poisson_op(shape, mean)
     return value
 
@@ -1196,17 +1244,42 @@ def multinomial(input, num_samples, replacement=True, seed=None):
     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.ops.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.
+        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.
 
     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: True.
+        replacement (bool, optional): Whether to draw with replacement or not. Default: ``True`` .
         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.
+          pseudo-random numbers, must be non-negative. Default: ``None`` .
 
     Returns:
         Tensor, has the same rows with input. The number of sampled indices of each row is `num_samples`.
@@ -1225,65 +1298,86 @@ def multinomial(input, num_samples, replacement=True, seed=None):
         >>> 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.
-        >>> input = Tensor([0, 9, 4, 0], mindspore.float32)
-        >>> output = ops.multinomial(input, 2)
-        >>> # print(output)
-        >>> # [1 2] or [2 1]
-        >>> # the case where the result is [2 1] in multiple times.
-        >>> # This is because the value corresponding to the index 1 is larger than the value of the index 2.
-        >>> print(len(output))
+        >>> # 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(input1, 2, replacement=False)
+        >>> output2 = ops.multinomial(input2, 2, replacement=False)
+        >>> # 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 False(Default).
-        >>> # If the extracted value is 0, the index value of 1 will be returned.
-        >>> input = Tensor([0, 9, 4, 0], mstype.float32)
-        >>> output = ops.multinomial(input, 4)
-        >>> print(output)
-        [1 1 2 1]
-        >>> # case 3: The output is random, num_sample == x_length = 4, and replacement is True,
-        >>> # Can extract the same elements。
-        >>> input = Tensor([0, 9, 4, 0], mstype.float32)
-        >>> output = ops.multinomial(input, 4, True)
-        >>> print(output)
-        [1 1 2 2]
+        >>> # replacement is True.
+        >>> output3 = ops.multinomial(input1, 10)
+        >>> # 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(input4, 10)
+        >>> # print(output4)
+        >>> # [[0 0 0 0 0 0 0 0 1 0]
+        >>> #  [1 1 1 1 1 0 1 1 1 1]]
     """
-    shape = P.Shape()
-    reshape = P.Reshape()
-    const_utils.check_valid_dim(len(shape(input)), "multinomial")
+    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")
     seed1, seed2 = _get_seed(seed, "multinomial")
     if not replacement:
         if shape(input)[-1] < num_samples:
-            const_utils.raise_value_error("For 'multinomial', the 'num_samples' must be less than "
-                                          "the last dimension of input without 'replacement', "
-                                          "but got 'num_samples': {} and "
-                                          "'replacement': {}".format(num_samples, replacement))
+            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]
-        random_uniform = P.UniformReal(seed1, seed2)((n_dist * shape(input)[-1],))
+        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],))
         if n_dist != 1:
             random_uniform = reshape(random_uniform, (n_dist, shape(input)[-1]))
-        vals = P.RealDiv()(P.Log()(random_uniform), input + 1e-6)
-        _, indices = P.TopK()(vals, num_samples)
+        real_div = _get_cache_prim(P.RealDiv)()
+        log = _get_cache_prim(P.Log)()
+        top_k = _get_cache_prim(P.TopK)()
+
+        vals = real_div(log(random_uniform), input + 1e-6)
+        _, indices = top_k(vals, num_samples)
         return indices
-    return P.Multinomial(seed1, seed2)(input, num_samples)
+    random_nomial = P.Multinomial(seed1, seed2)
+    random_nomial = _set_prim_op_user_data(random_nomial, "random_cache", False)
+    return random_nomial(input, num_samples)
 
 
 def _check_shape(input_shape):
     """Check 'shape' value."""
     if not isinstance(input_shape, tuple):
-        const_utils.raise_type_error("Type of 'shape' must be tuple, but got: {}".format(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("Elements of 'shape' must be int, but got: {}".format(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("Elements of 'shape' must be positive int, but got: {}".format(item))
+            const_utils.raise_value_error(f"Elements of 'shape' must be positive int, but got: {item}")
     return True
 
 
 def _check_param(op_name, param_name, param_value):
     """Check type of param_value is Tensor, int, or float."""
-    if not isinstance(param_value, (Tensor, int, float)):
+    if not isinstance(param_value, (Tensor, int, float, np.ndarray)):
         const_utils.raise_type_error("For '{}', the type of '{}' must be Tensor, int, or float, "
                                      "but got: {}".format(op_name, param_name, type(param_value)))
     return True