mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/operations/random_ops.py

@@ -82,12 +82,17 @@ class TruncatedNormal(Primitive):
 
     Note:
         - The value of `shape` must be greater than zero. The output length can not exceed 1000000.
-        - When `seed` or `seed2` is assigned a non-zero value, that value will be used as the seed.
-          Otherwise, a random seed will be used instead.
+        - Random seed: a set of regular random numbers can be obtained through some complex mathematical algorithms,
+          and the random seed determines the initial value of this random number. If the random seed is the same in two
+          separate calls, the random number generated will not change.
+        - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
+          to worry about which seed is more important.
 
     Args:
-        seed (int, optional): Random number seed. Default: 0.
-        seed2 (int, optional): The second seed to avoid seed collision. Default: 0.
+        seed (int, optional): The operator-level random seed, used to generate random numbers,
+            must be non-negative. Default: ``0`` .
+        seed2 (int, optional): The global random seed, which combines with the operator-level
+            random seed to determine the final generated random number, must be non-negative. Default: ``0`` .
         dtype (mindspore.dtype, optional): Specified output data type. Must be one of the following types:
             mindspore.float16, mindspore.float32 and mindspore.float64. Default: mindspore.float32.
 
@@ -140,12 +145,22 @@ class StandardNormal(Primitive):
 
     Refer to :func:`mindspore.ops.standard_normal` for more details.
 
+    Note:
+        - Random seed: a set of regular random numbers can be obtained through some complex mathematical algorithms,
+          and the random seed determines the initial value of this random number. If the random seed is the same in two
+          separate calls, the random number generated will not change.
+        - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
+          to worry about which seed is more important.
+
     Args:
-        seed (int): Random seed, must be non-negative. Default: 0.
-        seed2 (int): Random seed2, must be non-negative. A second seed to avoid seed collision. Default: 0.
+        seed (int, optional): The operator-level random seed, used to generate random numbers,
+            must be non-negative. Default: ``0`` .
+        seed2 (int, optional): The global random seed, which combines with the operator-level
+            random seed to determine the final generated random number, must be non-negative. Default: ``0`` .
 
     Inputs:
         - **shape** (tuple) - The shape of random tensor to be generated. Only constant value is allowed.
+          Supported dtypes: int32, int64.
 
     Outputs:
         Tensor. The shape is the same as the input `shape`. The dtype is float32.
@@ -181,9 +196,18 @@ class StandardLaplace(Primitive):
     .. math::
         \text{f}(x) = \frac{1}{2}\exp(-|x|)
 
+    Note:
+        - Random seed: a set of regular random numbers can be obtained through some complex mathematical algorithms,
+          and the random seed determines the initial value of this random number. If the random seed is the same in two
+          separate calls, the random number generated will not change.
+        - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
+          to worry about which seed is more important.
+
     Args:
-        seed (int): Random seed. Default: 0.
-        seed2 (int): Random seed2. Default: 0.
+        seed (int, optional): The operator-level random seed, used to generate random numbers,
+            must be non-negative. Default: ``0`` .
+        seed2 (int, optional): The global random seed, which combines with the operator-level
+            random seed to determine the final generated random number, must be non-negative. Default: ``0`` .
 
     Inputs:
         - **shape** (Union[tuple, Tensor]) - The shape of random tensor to be generated. Only constant value is allowed
@@ -203,6 +227,7 @@ class StandardLaplace(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import ops
         >>> shape = (4, 16)
         >>> stdlaplace = ops.StandardLaplace(seed=2)
         >>> output = stdlaplace(shape)
@@ -224,23 +249,18 @@ class RandomGamma(Primitive):
     r"""
     Produces random positive floating-point values x, distributed according to probability density function:
 
-    .. note::
-        - Random seed: A set of regular random numbers can be obtained through some complex mathematical algorithms,
-          and the random seed is the initial value of this random number. If the random seed is the same, the random
-          number obtained will not change.
-        - Global random seed and operator-level random seed are not set: Use the default value as the random seed.
-        - Global random seed is set, but operator-level random seed is not set: A global random seed will splice
-          with a randomly generated seed.
-        - Global random seed is not set, operator-level random seed is set: The default global random seed is used,
-          and splices with the operator-level random seed.
-        - Both Global random and operator-level random seed are set: The global random seed will splice with the
-          operator-level random seed.
+    Note:
+        - Random seed: a set of regular random numbers can be obtained through some complex mathematical algorithms,
+          and the random seed determines the initial value of this random number. If the random seed is the same in two
+          separate calls, the random number generated will not change.
+        - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
+          to worry about which seed is more important.
 
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
-            must be non-negative. Default: 0.
+            must be non-negative. Default: ``0`` .
         seed2 (int, optional): The global random seed, which combines with the operator-level
-            random seed to determine the final generated random number, must be non-negative. Default: 0.
+            random seed to determine the final generated random number, must be non-negative. Default: ``0`` .
 
     Inputs:
         - **shape** (Tensor) - The shape of random tensor to be generated. It must be constant value.
@@ -261,6 +281,9 @@ class RandomGamma(Primitive):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> shape = Tensor(np.array([3, 1, 2]), mstype.int32)
         >>> alpha = Tensor(np.array([[3, 4], [5, 6]]), mstype.float32)
         >>> gamma = ops.RandomGamma(seed=3)
@@ -291,9 +314,9 @@ class LogNormalReverse(Primitive):
 
     Args:
         mean (float, optional): the mean of normal distribution. With float data type.
-            Default: 1.0.
+            Default: ``1.0`` .
         std (float, optional): the std of normal distribution. With float data type.
-            Default: 2.0.
+            Default: ``2.0`` .
 
     Inputs:
         - **input** (Tensor) - The tensor to be generated with log-normal distribution.
@@ -335,22 +358,18 @@ class Gamma(PrimitiveWithInfer):
     .. math::
         \text{P}(x|α,β) = \frac{\exp(-x/β)}{{β^α}\cdot{\Gamma(α)}}\cdot{x^{α-1}}
 
-    .. note::
-        - Random seed: A set of regular random numbers can be obtained through some complex mathematical algorithms,
-          and the random seed is the initial value of this random number. If the random seed is the same, the random
-          number obtained will not change.
-        - Global random seed and operator-level random seed are not set: Use the default value as the random seed.
-        - Global random seed is set, but operator-level random seed is not set: A global random seed will splice
-          with a randomly generated seed.
-        - Global random seed is not set, operator-level random seed is set: The default global random seed is used,
-          and splices with the operator-level random seed.
-        - Both Global random and operator-level random seed are set: The global random seed will splice with the
-          operator-level random seed.
+    Note:
+        - Random seed: a set of regular random numbers can be obtained through some complex mathematical algorithms,
+          and the random seed determines the initial value of this random number. If the random seed is the same in two
+          separate calls, the random number generated will not change.
+        - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
+          to worry about which seed is more important.
 
     Args:
-        seed (int): The operator-level random seed, used to generate random numbers, must be non-negative. Default: 0.
-        seed2 (int): The global random seed and it will combile with the operator-level random seed to determine the
-            final generated random number, must be non-negative. Default: 0.
+        seed (int, optional): The operator-level random seed, used to generate random numbers,
+            must be non-negative. Default: ``0`` .
+        seed2 (int, optional): The global random seed, which combines with the operator-level
+            random seed to determine the final generated random number, must be non-negative. Default: ``0`` .
 
     Inputs:
         - **shape** (tuple) - The shape of random tensor to be generated. Only constant value is allowed.
@@ -373,6 +392,9 @@ class Gamma(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> shape = (3, 1, 2)
         >>> alpha = Tensor(np.array([[3, 4], [5, 6]]), mstype.float32)
         >>> beta = Tensor(np.array([1.0]), mstype.float32)
@@ -420,12 +442,17 @@ class ParameterizedTruncatedNormal(Primitive):
 
     Note:
         - The value in tensor `min` must be strictly less than `max` at any position after broadcasting.
-        - When `seed` or `seed2` is assigned a non-zero value, that value will be used as the seed.
-          Otherwise, a random seed will be used instead.
+        - Random seed: a set of regular random numbers can be obtained through some complex mathematical algorithms,
+          and the random seed determines the initial value of this random number. If the random seed is the same in two
+          separate calls, the random number generated will not change.
+        - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
+          to worry about which seed is more important.
 
     Args:
-        seed (int, optional): Random number seed. Default: 0.
-        seed2 (int, optional): The second seed to avoid seed collision. Default: 0.
+        seed (int, optional): The operator-level random seed, used to generate random numbers,
+            must be non-negative. Default: ``0`` .
+        seed2 (int, optional): The global random seed, which combines with the operator-level
+            random seed to determine the final generated random number, must be non-negative. Default: ``0`` .
 
     Inputs:
         - **shape** (Tensor) - The shape of random tensor to be generated.
@@ -492,9 +519,18 @@ class Poisson(PrimitiveWithInfer):
     .. math::
         \text{P}(i|μ) = \frac{\exp(-μ)μ^{i}}{i!}
 
+    Note:
+        - Random seed: a set of regular random numbers can be obtained through some complex mathematical algorithms,
+          and the random seed determines the initial value of this random number. If the random seed is the same in two
+          separate calls, the random number generated will not change.
+        - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
+          to worry about which seed is more important.
+
     Args:
-        seed (int): Random seed, must be non-negative. Default: 0.
-        seed2 (int): Random seed2, must be non-negative. Default: 0.
+        seed (int, optional): The operator-level random seed, used to generate random numbers,
+            must be non-negative. Default: ``0`` .
+        seed2 (int, optional): The global random seed, which combines with the operator-level
+            random seed to determine the final generated random number, must be non-negative. Default: ``0`` .
 
     Inputs:
         - **shape** (tuple) - The shape of random tensor to be generated. Only constant value is allowed.
@@ -557,12 +593,19 @@ class RandomPoisson(Primitive):
     .. math::
         \text{P}(i|μ) = \frac{\exp(-μ)μ^{i}}{i!}
 
-    Args:
-        seed (int, optional): Random number seed. If either `seed` or `seed2` are set to be non-zero,
-            the seed is set by the given seed. Otherwise, it is seeded by a random seed. Default: 0.
-        seed2 (int, optional): A second seed to avoid seed collision. Default: 0.
+    Note:
+        - Random seed: a set of regular random numbers can be obtained through some complex mathematical algorithms,
+          and the random seed determines the initial value of this random number. If the random seed is the same in two
+          separate calls, the random number generated will not change.
+        - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
+          to worry about which seed is more important.
 
-        dtype (mindspore.dtype, optional): The type of output. Default: mstype.int64.
+    Args:
+        seed (int, optional): The operator-level random seed, used to generate random numbers,
+            must be non-negative. Default: ``0`` .
+        seed2 (int, optional): The global random seed, which combines with the operator-level
+            random seed to determine the final generated random number, must be non-negative. Default: ``0`` .
+        dtype (mindspore.dtype, optional): The type of output. Default: ``mstype.int64`` .
 
     Inputs:
         - **shape** (Tensor) - The shape of random tensor to be generated, 1-D Tensor, whose dtype must be in
@@ -583,6 +626,9 @@ class RandomPoisson(Primitive):
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> shape = Tensor(np.array([2, 3]), mstype.int32)
         >>> rate = Tensor(np.array([2, 2]), mstype.int32)
         >>> seed = 0
@@ -618,11 +664,17 @@ class UniformInt(Primitive):
 
     Note:
         - The number in tensor minval must be strictly less than maxval at any position after broadcasting.
-        - If neither `seed` nor `seed2` is assigned a non-zero value, a randomly generated seed is used instead.
+        - Random seed: a set of regular random numbers can be obtained through some complex mathematical algorithms,
+          and the random seed determines the initial value of this random number. If the random seed is the same in two
+          separate calls, the random number generated will not change.
+        - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
+          to worry about which seed is more important.
 
     Args:
-        seed (int): Random seed, must be non-negative. Default: 0.
-        seed2 (int): Random seed2, must be non-negative. A second seed to avoid seed collision. Default: 0.
+        seed (int, optional): The operator-level random seed, used to generate random numbers,
+            must be non-negative. Default: ``0`` .
+        seed2 (int, optional): The global random seed, which combines with the operator-level
+            random seed to determine the final generated random number, must be non-negative. Default: ``0`` .
 
     Inputs:
         - **shape** (Union[tuple, Tensor]) - The shape of random tensor to be generated. Only constant value is allowed.
@@ -644,6 +696,8 @@ class UniformInt(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> shape = (2, 4)
         >>> minval = Tensor(1, mstype.int32)
         >>> maxval = Tensor(5, mstype.int32)
@@ -668,19 +722,24 @@ class UniformReal(Primitive):
     r"""
     Produces random floating-point values, uniformly distributed to the interval [0, 1).
 
+    Note:
+        - Random seed: a set of regular random numbers can be obtained through some complex mathematical algorithms,
+          and the random seed determines the initial value of this random number. If the random seed is the same in two
+          separate calls, the random number generated will not change.
+        - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
+          to worry about which seed is more important.
+        - Currently, on the Ascend platform, `shape` as a Tensor is not supported.
+          This is supported on CPU/GPU platforms. When the input is a Tensor,
+          the supported data types are as follows:
+
+          - GPU: int32, int64.
+          - CPU: int16, int32, int64.
+
     Args:
-        seed (int): The operator-level random seed, used to generate random numbers, must be non-negative. Default: 0.
-        seed2 (int): The global random seed and it will combile with the operator-level random seed to determine the
-            final generated random number, must be non-negative. Default: 0.
-
-    .. note::
-        - Global random seed and operator-level random seed are not set: Use a randomly generated seed.
-        - Global random seed is set, but operator-level random seed is not set: A global random seed will splice
-          with a randomly generated seed.
-        - Global random seed is not set, operator-level random seed is set: The default global random seed is used,
-          and splices with the operator-level random seed.
-        - Both Global random and operator-level random seed are set: The global random seed will splice with the
-          operator-level random seed.
+        seed (int, optional): The operator-level random seed, used to generate random numbers,
+            must be non-negative. Default: ``0`` .
+        seed2 (int, optional): The global random seed, which combines with the operator-level
+            random seed to determine the final generated random number, must be non-negative. Default: ``0`` .
 
     Inputs:
         - **shape** (Union[tuple, Tensor]) - The shape of tensor to be generated. Only constant value is allowed.
@@ -697,6 +756,7 @@ class UniformReal(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import ops
         >>> shape = (2, 2)
         >>> uniformreal = ops.UniformReal(seed=2)
         >>> output = uniformreal(shape)
@@ -704,6 +764,7 @@ class UniformReal(Primitive):
         >>> print(result)
         (2, 2)
     """
+
     @prim_attr_register
     def __init__(self, seed=0, seed2=0):
         """Initialize UniformReal"""
@@ -719,11 +780,19 @@ class RandomChoiceWithMask(Primitive):
 
     Refer to :func:`mindspore.ops.choice_with_mask` for more details.
 
+    Note:
+        - Random seed: a set of regular random numbers can be obtained through some complex mathematical algorithms,
+          and the random seed determines the initial value of this random number. If the random seed is the same in two
+          separate calls, the random number generated will not change.
+        - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
+          to worry about which seed is more important.
+
     Args:
-        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: 0.
-        seed2 (int, optional): Second seed to avoid collision. Default: 0.
+        count (int, optional): Number of items expected to get and the number must be greater than 0. Default: ``256`` .
+        seed (int, optional): The operator-level random seed, used to generate random numbers,
+            must be non-negative. Default: ``0`` .
+        seed2 (int, optional): The global random seed, which combines with the operator-level
+            random seed to determine the final generated random number, must be non-negative. Default: ``0`` .
 
     Inputs:
         - **input_x** (Tensor[bool]) - The input tensor.
@@ -732,13 +801,15 @@ class RandomChoiceWithMask(Primitive):
     Outputs:
         Two tensors, the first one is the index tensor and the other one is the mask tensor.
 
-        - **index** (Tensor) - The output shape is 2-D.
-        - **mask** (Tensor) - The output shape is 1-D.
+        - **index** (Tensor) - The output shape is 2-D, its shape is :math:`(count, rank of input_x)`.
+        - **mask** (Tensor) - The output shape is 1-D, its shape is :math:`(count)`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> rnd_choice_mask = ops.RandomChoiceWithMask()
         >>> input_x = Tensor(np.ones(shape=[240000, 4]).astype(np.bool))
         >>> output_y, output_mask = rnd_choice_mask(input_x)
@@ -765,19 +836,19 @@ class RandomCategorical(PrimitiveWithInfer):
     Generates random samples from a given categorical distribution tensor.
 
     Args:
-        dtype (mindspore.dtype): The type of output. Its value must be one of mindspore.int16,
-            mindspore.int32 and mindspore.int64. Default: mindspore.int64.
+        dtype (mindspore.dtype): The type of output. Its value must be one of mstype.int16,
+            mstype.int32 and mstype.int64. Default: ``mstype.int64`` .
 
     Inputs:
         - **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. Default: 0. Only constant values is allowed.
+        - **seed** (int) - Random seed. Default: ``0`` . Only constant values is allowed.
 
     Outputs:
-        - **output** (Tensor) - The output Tensor with shape :math:`(batch_size, num_samples)`.
+        - **output** (Tensor) - The output Tensor with shape :math:`(batch\_size, num\_samples)`.
 
     Raises:
-        TypeError: If `dtype` is not one of the following: mindspore.int16, mindspore.int32, mindspore.int64.
+        TypeError: If `dtype` is not one of the following: mstype.int16, mstype.int32, mstype.int64.
         TypeError: If `logits` is not a Tensor.
         TypeError: If neither `num_sample` nor `seed` is an int.
 
@@ -785,6 +856,9 @@ class RandomCategorical(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import nn, ops, Tensor
         >>> class Net(nn.Cell):
         ...   def __init__(self, num_sample):
         ...     super(Net, self).__init__()
@@ -819,13 +893,21 @@ class Multinomial(Primitive):
     row of tensor input.
 
     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.
+        - 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.
+        - Random seed: a set of regular random numbers can be obtained through some complex mathematical algorithms,
+          and the random seed determines the initial value of this random number. If the random seed is the same in two
+          separate calls, the random number generated will not change.
+        - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
+          to worry about which seed is more important.
 
     Args:
-        seed (int): Random seed, must be non-negative. Default: 0.
-        seed2 (int): Random seed2, must be non-negative. Default: 0.
-        dtype(dtype): The type of output, must be int32 or int64. Default: int32.
+        seed (int, optional): The operator-level random seed, used to generate random numbers,
+            must be non-negative. Default: ``0`` .
+        seed2 (int, optional): The global random seed, which combines with the operator-level
+            random seed to determine the final generated random number, must be non-negative. Default: ``0`` .
+        dtype(mindspore.dtype, optional): The type of output, must be ``mstype.int32`` or ``mstype.int64``.
+            Default: ``mstype.int32``.
 
     Inputs:
         - **x** (Tensor) - the input tensor containing the cumsum of probabilities, must be 1 or 2
@@ -838,13 +920,15 @@ class Multinomial(Primitive):
     Raises:
         TypeError: If neither `seed` nor `seed2` is an int.
         TypeError: If dtype of `num_samples` is not int.
-        TypeError: If `dtype` is not int32 or int64.
+        TypeError: If `dtype` is not mstype.int32 or mstype.int64.
         ValueError: If `seed` or `seed2` is less than 0.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> x = Tensor([[0., 9., 4., 0.]], mstype.float32)
         >>> multinomial = ops.Multinomial(seed=10)
         >>> output = multinomial(x, 2)
@@ -881,13 +965,13 @@ class MultinomialWithReplacement(Primitive):
 
     Args:
         numsamples (int): number of samples to draw, must be a nonnegative number.
-        replacement (bool, optional): Whether to draw with replacement or not. Default: False.
+        replacement (bool, optional): Whether to draw with replacement or not. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - the input tensor containing the cumsum of probabilities, must be 1 or 2
           dimensions.
-        - **seed** (Tensor) - If `seed` is set to -1, and `offset` is set to 0, the random number
-          generator is seeded by a random seed. Otherwise, it is seeded by the given seed.
+        - **seed** (Tensor) - If `seed` and 'offset' are both set to 0, the random number generator
+          is seeded by a random seed. Otherwise, it is seeded by the given seed and offset.
           Supported dtype: int64.
         - **offset** (Tensor) - Offset used to avoid seed collision. Supported dtype: int64.
 
@@ -898,6 +982,8 @@ class MultinomialWithReplacement(Primitive):
         ``CPU``
 
     Examples:
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> x = Tensor([[0., 9., 4., 0.]], mstype.float32)
         >>> seed = Tensor(2, mstype.int64)
         >>> offset = Tensor(5, mstype.int64)
@@ -924,10 +1010,36 @@ class UniformCandidateSampler(Primitive):
 
     Refer to :func:`mindspore.ops.uniform_candidate_sampler` for more details.
 
+    Args:
+        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 non-negative.
+        seed (int, optional): 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, optional): 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`` .
+
+    Inputs:
+        - **true_classes** (Tensor) - A Tensor. The target classes with a Tensor shape of
+          :math:`(batch\_size, num\_true)`.
+
+    Outputs:
+        - **sampled_candidates** (Tensor) - The sampled_candidates is independent of the true classes.
+          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)`.
+        - **sampled_expected_count** (Tensor) - The expected counts under the sampling distribution of
+          each of sampled_candidates. Shape: :math:`(num\_sampled, )`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> sampler = ops.UniformCandidateSampler(1, 3, False, 4, 1)
         >>> output1, output2, output3 = sampler(Tensor(np.array([[1], [3], [4], [6], [3]], dtype=np.int64)))
         >>> print(output1.shape)
@@ -964,7 +1076,6 @@ class UniformCandidateSampler(Primitive):
         self.add_prim_attr("side_effect_hidden", True)
 
 
-
 class LogUniformCandidateSampler(Primitive):
     r"""
     Generates random labels with a log-uniform distribution for sampled_candidates.
@@ -973,10 +1084,33 @@ class LogUniformCandidateSampler(Primitive):
 
     Refer to :func:`mindspore.ops.log_uniform_candidate_sampler` for more details.
 
+    Args:
+        num_true (int, optional): The number of target classes per training example. Default: ``1`` .
+        num_sampled (int, optional): The number of classes to randomly sample. Default: ``5`` .
+        unique (bool, optional): Determines whether sample with rejection. If `unique` is ``True`` ,
+          all sampled classes in a batch are unique. Default: ``True`` .
+        range_max (int, optional): The number of possible classes. When `unique` is ``True`` ,
+          `range_max` must be greater than or equal to `num_sampled`. Default: ``5`` .
+        seed (int, optional): Random seed, must be non-negative. Default: ``0`` .
+
+    Inputs:
+        - **true_classes** (Tensor) - The target classes. With data type of int64 and
+          shape :math:`(batch\_size, num\_true)` .
+
+    Outputs:
+        Tuple of 3 Tensors.
+
+        - **sampled_candidates** (Tensor) - A Tensor with shape :math:`(num\_sampled,)`
+          and the same type as `true_classes`.
+        - **true_expected_count** (Tensor) - A Tensor with the same shape as `true_classes and` type float32.
+        - **sampled_expected_count** (Tensor) - A Tensor with the same shape as `sampled_candidates` and type float32.
+
     Supported Platforms:
         ``Ascend`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> sampler = ops.LogUniformCandidateSampler(2, 5, True, 5)
         >>> output1, output2, output3 = sampler(Tensor(np.array([[1, 7], [0, 4], [3, 3]])))
         >>> print(output1, output2, output3)
@@ -1017,12 +1151,18 @@ class RandomShuffle(Primitive):
     r"""
     Randomly shuffles a Tensor along its first dimension.
 
+    Note:
+        - Random seed: a set of regular random numbers can be obtained through some complex mathematical algorithms,
+          and the random seed determines the initial value of this random number. If the random seed is the same in two
+          separate calls, the random number generated will not change.
+        - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
+          to worry about which seed is more important.
+
     Args:
-        seed (int, optional): Random seed. If `seed` or `seed2` is set to non-zero, the random number generator
-            will be seeded by the given seed. Otherwise, it will be seeded randomly.
-            The `seed` must be non-negative. Default: 0.
-        seed2 (int, optional): A second seed to avoid seed collision. If `seed` is 0, the `seed2` will be used as
-            the seed of the random generator. It must be non-negative. Default: 0.
+        seed (int, optional): The operator-level random seed, used to generate random numbers,
+            must be non-negative. Default: ``0`` .
+        seed2 (int, optional): The global random seed, which combines with the operator-level
+            random seed to determine the final generated random number, must be non-negative. Default: ``0`` .
 
     Inputs:
         - **x** (Tensor) - The Tensor need be shuffled.
@@ -1037,6 +1177,9 @@ class RandomShuffle(Primitive):
         ``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)
         >>> shuffle = ops.RandomShuffle(seed=1, seed2=1)
         >>> output = shuffle(x)
@@ -1058,8 +1201,8 @@ class Uniform(Primitive):
     Generates random numbers according to the Uniform random number distribution.
 
     Args:
-        minval(float):must be non-negative. Default: 0.0.
-        maxval(float):must be non-negative. Default: 1.0.
+        minval(float):must be non-negative. Default: ``0.0`` .
+        maxval(float):must be non-negative. Default: ``1.0`` .
 
     Inputs:
         - **x** (Tensor) - The x of random tensor to be generated.
@@ -1102,28 +1245,45 @@ class RandpermV2(Primitive):
     r"""
     Generates random permutation of integers from 0 to n-1 without repeating.
 
-    Refer to :func:`mindspore.ops.randperm` for more detail.
+    Refer to :func:`mindspore.ops.randperm` for more details.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        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.
+
+    Inputs:
+        - **n** (Union[Tensor, int]) - The input n Tensor with shape :math:`()` or :math:`(1,)`
+          and with data type of int64.
+        - **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.
+
+    Outputs:
+        Tensor. Its shape is specified by the required args `n`. Its type is specified by `dtype`.
+        Otherwise is default.
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend`` ``CPU``
 
     Examples:
         >>> n = Tensor([4], mstype.int64)
         >>> seed = 0
         >>> offset = 0
-        >>> randperm = ops.RandpermV2(layout=0, dtype=mstype.int64)
+        >>> randperm = ops.RandpermV2(dtype=mstype.int64)
         >>> output = randperm(n, seed, offset)
         >>> print(output)
         [1 0 2 3]
     """
 
     @prim_attr_register
-    def __init__(self, layout=0, dtype=mstype.int64):
+    def __init__(self, dtype=mstype.int64):
         """Initialize RandpermV2"""
         self.dtype = dtype
-        self.layout = layout
-        Validator.check_value_type('layout', layout, [int], self.name)
-        Validator.check_non_negative_int(layout, 'layout', self.name)
         valid_values = (mstype.int32, mstype.int64, mstype.int16, mstype.int8, mstype.uint8, mstype.float64
                         , mstype.float32, mstype.float16)
         Validator.check_type_name("dtype", dtype, valid_values, self.name)