mindspore 2.0.0a0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/ops/operations/random_ops.py

@@ -16,7 +16,7 @@
 from __future__ import absolute_import
 
 from mindspore.common._decorator import deprecated
-from mindspore._checkparam import Validator, Rel
+from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
 from mindspore.ops.primitive import PrimitiveWithInfer, prim_attr_register, Primitive
 from mindspore.ops._utils import get_broadcast_shape
@@ -53,15 +53,14 @@ class NonDeterministicInts(Primitive):
         ValueError: If the number of elements of output is more than 1000000.
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> shape = Tensor(np.array([2,2]), mstype.int32)
+        >>> shape = Tensor((3,4), mstype.int32)
         >>> ndints = ops.NonDeterministicInts(dtype=mstype.int32)
         >>> output = ndints(shape)
-        >>> print(output)
-        [[13031056   -141954883 ]
-         [ 140364228  290834494 ]]
+        >>> print(output.shape)
+        (3, 4)
     """
 
     @prim_attr_register
@@ -70,28 +69,29 @@ class NonDeterministicInts(Primitive):
         self.dtype = dtype
         self.add_prim_attr("max_length", 1000000)
         self.init_prim_io_names(inputs=["shape"], outputs=["output"])
-        valid_values = (mstype.int32, mstype.int64)
-        Validator.check_type_name("dtype", dtype, valid_values, self.name)
         self.add_prim_attr("side_effect_hidden", True)
+        valid_values = (mstype.int32, mstype.int64, mstype.uint32, mstype.uint64)
+        Validator.check_type_name("dtype", dtype, valid_values, self.name)
 
 
 class TruncatedNormal(Primitive):
     """
-    Returns a tensor of the specified shape filled with truncated normal values.
+    Returns a Tensor of the specified shape filled with truncated normal values.
 
-    The generated values follow a normal distribution.
+    The generated values conform to a Gaussian distribution.
 
-    .. warning::
-        The value of `shape` must be greater than zero. The output length can not exceed 1000000.
+    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.
 
     Args:
-        seed (int, optional): An optional int. Defaults to 0. 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.
-        seed2 (int, optional): An optional int. Defaults to 0. A second seed to avoid seed collision.
+        seed (int, optional): Random number seed. Default: 0.
+        seed2 (int, optional): The second seed to avoid seed collision. 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.
 
-    Inputs
+    Inputs:
         - **shape** (Tensor) - The shape of random tensor to be generated. Its type must be one of the following types:
           mindspore.int32 and mindspore.int64.
 
@@ -108,7 +108,7 @@ class TruncatedNormal(Primitive):
         ValueError: If the number of elements of output is more than 1000000.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> shape = Tensor(np.array([2, 2]), mstype.int32)
@@ -126,12 +126,12 @@ class TruncatedNormal(Primitive):
         """Initialize TruncatedNormal"""
         self.dtype = dtype
         self.add_prim_attr("max_length", 1000000)
+        self.add_prim_attr("side_effect_hidden", True)
         self.init_prim_io_names(inputs=["shape"], outputs=["output"])
         Validator.check_value_type('seed', seed, [int], self.name)
         Validator.check_value_type('seed2', seed2, [int], self.name)
         valid_values = (mstype.float16, mstype.float32, mstype.float64)
         Validator.check_type_name("dtype", dtype, valid_values, self.name)
-        self.add_prim_attr("side_effect_hidden", True)
 
 
 class StandardNormal(Primitive):
@@ -140,6 +140,16 @@ class StandardNormal(Primitive):
 
     Refer to :func:`mindspore.ops.standard_normal` for more details.
 
+    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.
+
+    Inputs:
+        - **shape** (tuple) - The shape of random tensor to be generated. Only constant value is allowed.
+
+    Outputs:
+        Tensor. The shape is the same as the input `shape`. The dtype is float32.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -169,7 +179,7 @@ class StandardLaplace(Primitive):
     It is defined as:
 
     .. math::
-        \text{f}(x) = \frac{1}{2}\exp(-|x|),
+        \text{f}(x) = \frac{1}{2}\exp(-|x|)
 
     Args:
         seed (int): Random seed. Default: 0.
@@ -277,11 +287,13 @@ class LogNormalReverse(Primitive):
     .. math::
         \text{f}(x;1.0,2.0)=\frac{1}{x\delta \sqrt[]{2\pi} }e^{-\frac{(\ln x-\mu )^2}{2\delta ^2} }
 
+    where \mu, \delta is mean and standard deviation of  lognormal distribution respectively.
+
     Args:
         mean (float, optional): the mean of normal distribution. With float data type.
-            Default: 2.0.
-        std (float, optional): the std of normal distribution. With float data type.
             Default: 1.0.
+        std (float, optional): the std of normal distribution. With float data type.
+            Default: 2.0.
 
     Inputs:
         - **input** (Tensor) - The tensor to be generated with log-normal distribution.
@@ -311,47 +323,9 @@ class LogNormalReverse(Primitive):
     @prim_attr_register
     def __init__(self, mean=1.0, std=2.0):
         """Initialize LogNormalReverse"""
+        self.add_prim_attr("side_effect_hidden", True)
         Validator.check_value_type("mean", mean, [float], self.name)
         Validator.check_value_type("std", std, [float], self.name)
-        self.add_prim_attr("side_effect_hidden", True)
-
-
-class RandomGammaGrad(Primitive):
-    r"""
-    Computes the derivative of a random sample of Gamma with respect to alpha.:
-
-    Inputs:
-        - **alpha** (Tensor) - α is the shape parameter of RandomGamma distribution.
-        It must be greater than 0. Must be one of the following types: float32, float64.
-        - **sample** (Tensor) - The sample of random gamma tensor. Must be one of the
-        following types: float32, float64.
-
-    Outputs:
-        The dtype is the same type as alpha.
-        The output shape is derived from the input through broadcasting.
-
-    Raises:
-        TypeError: If data type of `alpha` and `sample` is not float32 or float64.
-        TypeError: If data type of `alpha` and `sample` is not same.
-        ValueError: If the shape last dim of `sample` and `alpha` is not equal.
-
-    Supported Platforms:
-        ``GPU``
-
-    Examples:
-        >>> alpha = Tensor(np.array([1., 0.6, 3., 26.]), mstype.float32)
-        >>> sample = Tensor(np.array([6., 7, 11., 0.5]), mstype.float32)
-        >>> randomgammagrad = ops.RandomGammaGrad()
-        >>> output = randomgammagrad(alpha, sample)
-        >>> print(output)
-        [2.5142431 3.4334087 1.8847835 0.07780622]
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize RandomGammaGrad"""
-        self.init_prim_io_names(inputs=['alpha', 'sample'], outputs=['output'])
-        self.add_prim_attr("side_effect_hidden", True)
 
 
 class Gamma(PrimitiveWithInfer):
@@ -445,24 +419,29 @@ class ParameterizedTruncatedNormal(Primitive):
     `min` and `max` should be :math:`()` or :math:`(batch\_size, )`.
 
     Note:
-        The value in tensor `min` must be strictly less than `max` at any position after broadcasting.
+        - 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.
 
     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.
+        seed (int, optional): Random number seed. Default: 0.
+        seed2 (int, optional): The second seed to avoid seed collision. Default: 0.
 
     Inputs:
-        - **shape** (Tensor) - The shape of random tensor to be generated. Its type must be one of the following types:
-          int32 and int64.
+        - **shape** (Tensor) - The shape of random tensor to be generated.
+          It has shape :math:`(batch\_size, *)` where :math:`*` is an additional
+          dimension with a length of no less than 1.
+          Its type must be one of the following types: int32 and int64.
         - **mean** (Tensor) - The parameter defines the mean of truncated normal distribution.
+          It has shape :math:`()` or :math:`(batch\_size, )`.
           Its type must be one of the following types:float16, float32, float64.
         - **stdevs** (Tensor) - The parameter defines the standard deviation for truncation of
-          the normal distribution. It must be greater than 0 and have the same type as means.
+          the normal distribution.
+          It must be greater than 0 and have the same shape and type as means.
         - **min** (Tensor) - The parameter defines the minimum of
-          truncated normal distribution. It must have the same type as means.
+          truncated normal distribution. It must have the same shape and type as means.
         - **max** (Tensor) - The parameter defines the maximum of
-          truncated normal distribution. It must have the same type as means.
+          truncated normal distribution. It must have the same shape and type as means.
 
     Outputs:
         Tensor. Its shape is specified by the input `shape` and it must have the same type as means.
@@ -479,14 +458,14 @@ class ParameterizedTruncatedNormal(Primitive):
         ValueError: If `shape` is not a 1-D tensor.
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> shape = Tensor(np.array([2, 3]), mstype.int32)
-        >>> mean = Tensor(np.array([0], mstype.float32))
-        >>> stdevs = Tensor(np.array([1], mstype.float32))
-        >>> min = Tensor(np.array([-100], mstype.float32))
-        >>> max = Tensor(np.array([100],  mstype.float32))
+        >>> mean = Tensor(np.array([0]), mstype.float32)
+        >>> stdevs = Tensor(np.array([1]), mstype.float32)
+        >>> min = Tensor(np.array([-100]), mstype.float32)
+        >>> max = Tensor(np.array([100]),  mstype.float32)
         >>> seed = 1
         >>> seed2 = 2
         >>> parameterized_truncated_normal = ops.ParameterizedTruncatedNormal(seed=seed, seed2=seed2)
@@ -501,9 +480,9 @@ class ParameterizedTruncatedNormal(Primitive):
         """Initialize ParameterizedTruncatedNormal"""
         self.init_prim_io_names(
             inputs=['shape', 'mean', 'stdevs', 'min', 'max'], outputs=['y'])
+        self.add_prim_attr("side_effect_hidden", True)
         Validator.check_value_type('seed', seed, [int], self.name)
         Validator.check_value_type('seed2', seed2, [int], self.name)
-        self.add_prim_attr("side_effect_hidden", True)
 
 
 class Poisson(PrimitiveWithInfer):
@@ -601,7 +580,7 @@ class RandomPoisson(Primitive):
         ValueError: If `shape` elements are negative.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> shape = Tensor(np.array([2, 3]), mstype.int32)
@@ -620,10 +599,10 @@ class RandomPoisson(Primitive):
         self.init_prim_io_names(inputs=['shape', 'rate'], outputs=['output'])
         Validator.check_value_type('seed', seed, [int], self.name)
         Validator.check_value_type('seed2', seed2, [int], self.name)
+        self.add_prim_attr("side_effect_hidden", True)
         valid_values = (mstype.int64, mstype.int32,
                         mstype.float16, mstype.float32, mstype.float64)
         Validator.check_type_name("dtype", dtype, valid_values, self.name)
-        self.add_prim_attr("side_effect_hidden", True)
 
 
 class UniformInt(Primitive):
@@ -638,17 +617,18 @@ class UniformInt(Primitive):
     the :math:`b` indicates the max distribution parameter.
 
     Note:
-        The number in tensor minval must be strictly less than maxval at any position after broadcasting.
+        - 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.
 
     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.
 
     Inputs:
-        - **shape** (tuple) - The shape of random tensor to be generated. Only constant value is allowed.
-        - **minval** (Tensor) - The distribution parameter, a.
+        - **shape** (Union[tuple, Tensor]) - The shape of random tensor to be generated. Only constant value is allowed.
+        - **minval** (Tensor) - The distribution parameter, :math:`a`.
           It defines the minimum possibly generated value, with int32 data type. Only one number is supported.
-        - **maxval** (Tensor) - The distribution parameter, b.
+        - **maxval** (Tensor) - The distribution parameter, :math:`b`.
           It defines the maximum possibly generated value, with int32 data type. Only one number is supported.
 
     Outputs:
@@ -656,7 +636,7 @@ class UniformInt(Primitive):
 
     Raises:
         TypeError: If neither `seed` nor `seed2` is an int.
-        TypeError: If `shape` is not a tuple.
+        TypeError: If `shape` is neither a tuple nor a Tensor.
         TypeError: If neither `minval` nor `maxval` is a Tensor.
         ValueError: If `shape` is not a constant value.
 
@@ -694,7 +674,7 @@ class UniformReal(Primitive):
             final generated random number, must be non-negative. Default: 0.
 
     .. note::
-        - Global random seed and operator-level random seed are not set: Use the default value as the random seed.
+        - 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,
@@ -703,14 +683,14 @@ class UniformReal(Primitive):
           operator-level random seed.
 
     Inputs:
-        - **shape** (tuple) - The shape of tensor to be generated. Only constant value is allowed.
+        - **shape** (Union[tuple, Tensor]) - The shape of tensor to be generated. Only constant value is allowed.
 
     Outputs:
         Tensor. The shape that the input 'shape' denotes. The dtype is float32.
 
     Raises:
         TypeError: If `seed` or `seed2` is not an int.
-        TypeError: If `shape` is not a tuple.
+        TypeError: If `shape` is neither a tuple nor a Tensor.
         ValueError: If `shape` is not a constant value.
 
     Supported Platforms:
@@ -739,6 +719,22 @@ class RandomChoiceWithMask(Primitive):
 
     Refer to :func:`mindspore.ops.choice_with_mask` for more details.
 
+    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.
+
+    Inputs:
+        - **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.
+
+    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.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -765,7 +761,7 @@ class RandomChoiceWithMask(Primitive):
 
 
 class RandomCategorical(PrimitiveWithInfer):
-    """
+    r"""
     Generates random samples from a given categorical distribution tensor.
 
     Args:
@@ -773,12 +769,12 @@ class RandomCategorical(PrimitiveWithInfer):
             mindspore.int32 and mindspore.int64. Default: mindspore.int64.
 
     Inputs:
-        - **logits** (Tensor) - The input tensor. 2-D Tensor with shape [batch_size, num_classes].
+        - **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.
 
     Outputs:
-        - **output** (Tensor) - The output Tensor with shape [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.
@@ -833,8 +829,7 @@ class Multinomial(Primitive):
 
     Inputs:
         - **x** (Tensor) - the input tensor containing the cumsum of probabilities, must be 1 or 2
-          dimensions. Must be one of the following types: float16, float32, float64. CPU and GPU
-          supports x 1 or 2 dimensions and Ascend only supports 2 dimensions.
+          dimensions.
         - **num_samples** (int) - number of samples to draw, must be a nonnegative number.
 
     Outputs:
@@ -842,19 +837,18 @@ class Multinomial(Primitive):
 
     Raises:
         TypeError: If neither `seed` nor `seed2` is an int.
-        TypeError: If `x` is not a Tensor whose dtype is float16, float32, float64.
         TypeError: If dtype of `num_samples` is not int.
         TypeError: If `dtype` is not int32 or int64.
         ValueError: If `seed` or `seed2` is less than 0.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor([[0., 9., 4., 0.]], mstype.float32)
         >>> multinomial = ops.Multinomial(seed=10)
         >>> output = multinomial(x, 2)
-        >>> print(output) # run in CPU
+        >>> print(output)
         [[1 1]]
     """
 
@@ -873,21 +867,42 @@ class Multinomial(Primitive):
 
 class MultinomialWithReplacement(Primitive):
     r"""
-    Returns a tensor where each row contains numsamples indices sampled from the multinomial distribution.
+    Returns a tensor where each row contains `numsamples` indices sampled from the multinomial distribution
+    with replacement. It diffs from `Multinomial` in that it allows the same outcome to be chosen multiple times.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Refer to :func:`mindspore.ops.multinomial_with_replacement` for more details.
 
     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.
 
-    Refer to :func:`mindspore.ops.multinomial_with_replacement` for more details.
+    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.
+
+    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.
+          Supported dtype: int64.
+        - **offset** (Tensor) - Offset used to avoid seed collision. Supported dtype: int64.
+
+    Outputs:
+        Tensor with the same rows as `x`, each row has `numsamples` sampled indices.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``CPU``
 
     Examples:
         >>> x = Tensor([[0., 9., 4., 0.]], mstype.float32)
+        >>> seed = Tensor(2, mstype.int64)
+        >>> offset = Tensor(5, mstype.int64)
         >>> multinomialwithreplacement = ops.MultinomialWithReplacement(numsamples=2,replacement=True)
-        >>> output = multinomialwithreplacement(x, 2, 5)
+        >>> output = multinomialwithreplacement(x, seed, offset)
         >>> print(output)
         [[1 1]]
     """
@@ -901,7 +916,7 @@ class MultinomialWithReplacement(Primitive):
         self.add_prim_attr("side_effect_hidden", True)
 
 
-class UniformCandidateSampler(PrimitiveWithInfer):
+class UniformCandidateSampler(Primitive):
     r"""
     Uniform candidate sampler.
 
@@ -935,30 +950,19 @@ class UniformCandidateSampler(PrimitiveWithInfer):
         Validator.check_value_type(
             "remove_accidental_hits", remove_accidental_hits, [bool], self.name)
         Validator.check("value of num_true", num_true,
-                        '', 0, Rel.GT, self.name)
+                        '', 0, Validator.GT, self.name)
         Validator.check("value of num_sampled", num_sampled,
-                        '', 0, Rel.GT, self.name)
+                        '', 0, Validator.GT, self.name)
         Validator.check("value of range_max", range_max,
-                        '', 0, Rel.GT, self.name)
+                        '', 0, Validator.GT, self.name)
         self.num_true = num_true
         if unique:
             Validator.check('value of num_sampled', num_sampled,
-                            "value of range_max", range_max, Rel.LE, self.name)
-        Validator.check("value of seed", seed, '', 0, Rel.GE, self.name)
+                            "value of range_max", range_max, Validator.LE, self.name)
+        Validator.check("value of seed", seed, '', 0, Validator.GE, self.name)
         self.num_sampled = num_sampled
         self.add_prim_attr("side_effect_hidden", True)
 
-    def infer_dtype(self, true_classes_type):
-        Validator.check_subclass(
-            "true_classes_type", true_classes_type, mstype.tensor, self.name)
-        Validator.check_tensor_dtype_valid("true_classes_type", true_classes_type,
-                                           (mstype.int32, mstype.int64), self.name)
-        return true_classes_type, mstype.float32, mstype.float32
-
-    def infer_shape(self, true_classes_shape):
-        Validator.check("true_class.shape[1]", true_classes_shape[1],
-                        "num_true", self.num_true, Rel.EQ, self.name)
-        return [self.num_sampled], true_classes_shape, [self.num_sampled]
 
 
 class LogUniformCandidateSampler(Primitive):
@@ -996,16 +1000,16 @@ class LogUniformCandidateSampler(Primitive):
         Validator.check_value_type("range_max", range_max, [int], self.name)
         Validator.check_value_type("seed", seed, [int], self.name)
         self.num_true = Validator.check_number(
-            "num_true", num_true, 1, Rel.GE, self.name)
+            "num_true", num_true, 1, Validator.GE, self.name)
         self.num_sampled = Validator.check_number(
-            "num_sampled", num_sampled, 1, Rel.GE, self.name)
-        Validator.check_number("range_max", range_max, 1, Rel.GE, self.name)
+            "num_sampled", num_sampled, 1, Validator.GE, self.name)
+        Validator.check_number("range_max", range_max, 1, Validator.GE, self.name)
         if unique:
             Validator.check("range_max", range_max, "num_sampled",
-                            num_sampled, Rel.GE, self.name)
+                            num_sampled, Validator.GE, self.name)
         self.range_max = range_max
         self.unique = unique
-        self.seed = Validator.check_number("seed", seed, 0, Rel.GE, self.name)
+        self.seed = Validator.check_number("seed", seed, 0, Validator.GE, self.name)
         self.add_prim_attr("side_effect_hidden", True)
 
 
@@ -1014,9 +1018,10 @@ class RandomShuffle(Primitive):
     Randomly shuffles a Tensor along its first dimension.
 
     Args:
-        seed (int): 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): Random seed2, a second seed to avoid seed collision. If `seed` is 0, the `seed2` will be used as
+        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.
 
     Inputs:
@@ -1046,3 +1051,80 @@ class RandomShuffle(Primitive):
         self.add_prim_attr("side_effect_hidden", True)
         Validator.check_non_negative_int(seed, "seed", self.name)
         Validator.check_non_negative_int(seed2, "seed2", self.name)
+
+
+class Uniform(Primitive):
+    r"""
+    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.
+
+    Inputs:
+        - **x** (Tensor) - The x of random tensor to be generated.
+          Only constant value is allowed, and the date type is float16, float32, float64.
+
+    Raises:
+        TypeError: If `minval` or `maxval` is not a float.
+        TypeError: If `x`is not a Tensor.
+        ValueError: If `minval` is larger than `maxval`.
+
+    Outputs:
+        - **output** (Tensor) - With the same type and shape as the 'x'.
+
+    Supported Platforms:
+        ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor(np.random.randn(3,4), mstype.float64)
+        >>> uniform = Uniform(minval=1.0, maxval=2.0)
+        >>> y = uniform(x)
+        >>> print(y.shape)
+        (3, 4)
+    """
+
+    @prim_attr_register
+    def __init__(self, minval=0., maxval=1., seed=0, offset=0):
+        """Initialize Uniform"""
+        self.init_prim_io_names(inputs=['x'], outputs=['y'])
+        self.add_prim_attr("from", minval)
+        self.add_prim_attr("to", maxval)
+        Validator.check_value_type('seed', seed, [int], self.name)
+        Validator.check_value_type('offset', offset, [int], self.name)
+        Validator.check('minval', minval, 'maxval', maxval, Validator.LE, self.name)
+        Validator.check_non_negative_float(minval, "minval", self.name)
+        Validator.check_non_negative_float(maxval, "maxval", self.name)
+        self.add_prim_attr("side_effect_hidden", True)
+
+
+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.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> n = Tensor([4], mstype.int64)
+        >>> seed = 0
+        >>> offset = 0
+        >>> randperm = ops.RandpermV2(layout=0, 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):
+        """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)
+        self.add_prim_attr("side_effect_hidden", True)