mindspore 1.10.0__cp39-cp39-win_amd64.whl → 2.0.0rc1__cp39-cp39-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
@@ -30,37 +30,37 @@ class NonDeterministicInts(Primitive):
     that a given type can represent.
 
     .. warning::
-        The value of "shape" must be greater than zero. The output length must be less than 1000000.
+        The value of `shape` must be greater than zero.
+        The number of elements of output can not exceed 1000000.
 
     Args:
-        dtype (mindspore.dtype): The type of output. Its value must be one of the following types: mindspore.int32
-            and mindspore.int64. Default: mindspore.int64.
+        dtype (mindspore.dtype, optional): The date type of output. The supported values are: mstype.int32
+            and mstype.int64. Default: mstype.int64.
 
     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.
+        - **shape** (Tensor) - The shape of random tensor to be generated. The supported values are:
+          int32 and int64.
 
     Outputs:
-        Tensor. Its shape is spcified by the input `shape`. Its type is spcified by `dtype`.
+        Tensor. Its shape is specified by the input `shape`. Its type is specified by `dtype`.
 
     Raises:
         TypeError: If `shape` is not a Tensor.
-        TypeError: If `dtype` and input tensor type are not allowed.
+        TypeError: If `dtype` is not mstype.int32 or mstype.int64.
         ValueError: If `shape` has negative elements.
         ValueError: If `shape` has less than 2 elements.
         ValueError: If `shape` is not a 1-D tensor.
         ValueError: If the number of elements of output is more than 1000000.
 
     Supported Platforms:
-        ``Ascend`` ``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
@@ -69,38 +69,40 @@ 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)
+        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 must be less than 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): 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): An optional int. Defaults to 0. A second seed to avoid seed collision.
-        dtype (mindspore.dtype): Must be one of the following types: mindspore.float16, mindspore.float32 and
-            mindspore.float64. Default: mindspore.float32.
+        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:
         - **shape** (Tensor) - The shape of random tensor to be generated. Its type must be one of the following types:
           mindspore.int32 and mindspore.int64.
 
     Outputs:
-        Tensor. Its shape is spcified by the input `shape`. Its type is spcified by `dtype`.
+        Tensor. Its shape is specified by the input `shape`. Its type is specified by `dtype`.
         Its values are in [-2,2].
 
     Raises:
         TypeError: If `shape` is not a Tensor.
-        TypeError: If `dtype` and input tensor type are not allowed.
-        TypeError: If `Seed` is not an integer.
+        TypeError: If data type of `dtype` and `shape` are not allowed.
+        TypeError: If `seed` is not an integer.
         ValueError: If `shape` elements are not positive.
         ValueError: If `shape` is not a 1-D tensor.
         ValueError: If the number of elements of output is more than 1000000.
@@ -124,6 +126,7 @@ 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)
@@ -135,7 +138,17 @@ class StandardNormal(Primitive):
     r"""
     Generates random numbers according to the standard Normal (or Gaussian) random number distribution.
 
-    Refer to :func:`mindspore.ops.standard_normal` for more detail.
+    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``
@@ -160,14 +173,13 @@ class StandardNormal(Primitive):
         Validator.check_non_negative_int(seed2, "seed2", self.name)
 
 
-
 class StandardLaplace(Primitive):
     r"""
     Generates random numbers according to the Laplace random number distribution (mean=0, lambda=1).
     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.
@@ -185,6 +197,7 @@ class StandardLaplace(Primitive):
         TypeError: If shape is neither a tuple nor a Tensor.
         ValueError: If seed or seed2 is not a non-negative int.
         ValueError: If shape is a tuple containing non-positive items.
+        ValueError: If shape is a Tensor, and the rank of the Tensor is not equal to 1.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -224,15 +237,15 @@ class RandomGamma(Primitive):
           operator-level random seed.
 
     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** (Tensor) - The shape of random tensor to be generated.
-        Must be one of the following types: int32, int64. 1-D integer tensor.
-        - **alpha** (Tensor) - α is the shape parameter of RandomGamma distribution.
-        It must be greater than 0. Must be one of the following types: half, float32, float64.
+        - **shape** (Tensor) - The shape of random tensor to be generated. It must be constant value.
+        - **alpha** (Tensor) - α is the shape parameter of RandomGamma distribution, it mainly determines the
+          shape of the graph curve. It must be greater than 0 and have date type float32.
 
     Outputs:
         Tensor. The shape should be equal to the concat shape between the input `shape` and `alpha`.
@@ -266,6 +279,55 @@ class RandomGamma(Primitive):
         Validator.check_non_negative_int(seed2, "seed2", self.name)
 
 
+class LogNormalReverse(Primitive):
+    r"""
+    Fills the elements of the input tensor with log normal values initialized by
+    given mean and std:
+
+    .. 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: 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.
+          Must be one of the following types: float16, float32, float64.
+
+    Outputs:
+        Tensor. A Tensor with the same type and shape of input.
+
+    Raises:
+        TypeError: If `input` is not Tensor.
+        ValueError: If `input` is NULL.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor(np.random.randn(3,4),mstype.float64)
+        >>> mean = 2.0
+        >>> std = 1.0
+        >>> lognormalreverse = ops.LogNormalReverse(mean, std)
+        >>> output = lognormalreverse(x)
+        >>> result = output.shape
+        >>> print(result)
+        (3, 4)
+    """
+
+    @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)
+
+
 class Gamma(PrimitiveWithInfer):
     r"""
     Produces random positive floating-point values x, distributed according to probability density function:
@@ -324,7 +386,8 @@ class Gamma(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self, seed=0, seed2=0):
         """Initialize RandomGamma"""
-        self.init_prim_io_names(inputs=['shape', 'alpha', 'beta'], outputs=['output'])
+        self.init_prim_io_names(
+            inputs=['shape', 'alpha', 'beta'], outputs=['output'])
         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)
@@ -350,54 +413,59 @@ class Gamma(PrimitiveWithInfer):
 
 
 class ParameterizedTruncatedNormal(Primitive):
-    """
+    r"""
     Returns a tensor of the specified shape filled with truncated normal values.
-
-    When 'shape' is (batch_size, *), the shape of 'mean', 'stdevs', 'min', 'max' should be () or (batch_size, ).
+    When `shape` is :math:`(batch\_size, *)`, the shape of `mean`, `stdevs`,
+    `min` and `max` should be :math:`()` or :math:`(batch\_size, )`.
 
     Note:
-        The number in tensor minval must be strictly less than maxval 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): 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): 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.
 
     Inputs:
-        - **shape** (Tensor) - The shape of random tensor to be generated. Its type must be one of the following types:
-          int32 and int64.
-        - **mean** (Tensor) - A Tensor. The parameter defines the mean of truncated normal distribution.
+        - **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) - A 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.
-        - **min** (Tensor) - The distribution parameter, a. The parameter defines the minimum of
-          truncated normal distribution. It must have the same type as means.
-        - **max** (Tensor) - The distribution parameter, b. The parameter defines the maximum of
-          truncated normal distribution. It must have the same type as means.
+        - **stdevs** (Tensor) - The parameter defines the standard deviation for truncation of
+          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 shape and type as means.
+        - **max** (Tensor) - The parameter defines the maximum of
+          truncated normal distribution. It must have the same shape and type as means.
 
     Outputs:
-        Tensor. Its shape is spcified by the input `shape` and it must have the same type as means.
+        Tensor. Its shape is specified by the input `shape` and it must have the same type as means.
 
     Raises:
-        TypeError: If `shape`, `mean`, `stdevs`, `min`, `max` and input tensor type are not allowed.
+        TypeError: If data type of `shape`, `mean`, `stdevs`, `min` and `max` are not allowed.
         TypeError: If `mean`, `stdevs`, `min`, `max` don't have the same type.
-        TypeError: If `mean` or `stdevs` or `minval` or `maxval` is not a Tensor.
-        ValueError: When 'shape' is (batch_size, *), if the shape of 'mean', 'stdevs', 'min', 'max'
-                    is not () or (batch_size, ).
+        TypeError: If any of `shape`, `mean`, `stdevs`, `min` and `max` is not Tensor.
+        ValueError: When `shape` is :math:`(batch\_size, *)`, if the shape of `mean`, `stdevs`, `min` or `max`
+                    is not :math:`()` or :math:`(batch\_size, )`.
         ValueError: If `shape` elements are not positive.
         ValueError: If `stdevs` elements are not positive.
         ValueError: If `shape` has less than 2 elements.
         ValueError: If `shape` is not a 1-D tensor.
 
     Supported Platforms:
-        ``Ascend`` ``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)
@@ -410,17 +478,19 @@ class ParameterizedTruncatedNormal(Primitive):
     @prim_attr_register
     def __init__(self, seed=0, seed2=0):
         """Initialize ParameterizedTruncatedNormal"""
-        self.init_prim_io_names(inputs=['shape', 'mean', 'stdevs', 'min', 'max'], outputs=['y'])
+        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)
 
 
 class Poisson(PrimitiveWithInfer):
     r"""
-    Produces random non-negative integer values i, distributed according to discrete probability function:
+    Produces random non-negative integer values i. Distributed according to discrete probability function:
 
     .. math::
-        \text{P}(i|μ) = \frac{\exp(-μ)μ^{i}}{i!},
+        \text{P}(i|μ) = \frac{\exp(-μ)μ^{i}}{i!}
 
     Args:
         seed (int): Random seed, must be non-negative. Default: 0.
@@ -469,8 +539,10 @@ class Poisson(PrimitiveWithInfer):
         Validator.check_value_type("shape", shape_v, [tuple], self.name)
         for i, shape_i in enumerate(shape_v):
             Validator.check_positive_int(shape_i, f'shape[{i}]', self.name)
-        Validator.check_tensor_dtype_valid("mean", mean["dtype"], [mstype.float32], self.name)
-        broadcast_shape = get_broadcast_shape(mean['shape'], shape_v, self.name, arg_name1="mean", arg_name2="shape")
+        Validator.check_tensor_dtype_valid(
+            "mean", mean["dtype"], [mstype.float32], self.name)
+        broadcast_shape = get_broadcast_shape(
+            mean['shape'], shape_v, self.name, arg_name1="mean", arg_name2="shape")
         out = {
             'shape': broadcast_shape,
             'dtype': mstype.int32,
@@ -480,25 +552,26 @@ class Poisson(PrimitiveWithInfer):
 
 class RandomPoisson(Primitive):
     r"""
-    Produces random non-negative  values i, distributed according to discrete probability function:
+    Produces random non-negative values i, distributed according to discrete probability function:
 
     .. math::
-        \text{P}(i|μ) = \frac{\exp(-μ)μ^{i}}{i!},
+        \text{P}(i|μ) = \frac{\exp(-μ)μ^{i}}{i!}
 
     Args:
-         seed (int): 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): An optional int. Defaults to 0. A second seed to avoid seed collision.
-         dtype (mindspore.dtype): The type of output. Default: mindspore.int64.
+        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.
+
+        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
-                               [int32, int64]
+          [int32, int64].
         - **rate** (Tensor) - μ parameter the distribution was constructed with. The parameter defines mean number
-          of occurrences of the event. Its type must be in [float16, float32, float64, int32, int64]
+          of occurrences of the event. Its type must be in [float16, float32, float64, int32, int64].
 
     Outputs:
-        Tensor. Its shape is (*shape, *rate.shape). Its type is spcified by `dtype`.
+        Tensor. Its shape is :math:`(*shape, *rate.shape)`. Its type is specified by `dtype`.
 
     Raises:
         TypeError: If `shape` is not a Tensor or its dtype is not int32 or int64.
@@ -507,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)
@@ -526,7 +599,9 @@ 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)
-        valid_values = (mstype.int64, mstype.int32, mstype.float16, mstype.float32, mstype.float64)
+        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)
 
 
@@ -542,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:
@@ -560,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.
 
@@ -581,7 +657,8 @@ class UniformInt(Primitive):
     @prim_attr_register
     def __init__(self, seed=0, seed2=0):
         """Initialize UniformInt"""
-        self.init_prim_io_names(inputs=['shape', 'minval', 'maxval'], outputs=['output'])
+        self.init_prim_io_names(
+            inputs=['shape', 'minval', 'maxval'], outputs=['output'])
         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)
@@ -597,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,
@@ -606,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:
@@ -629,7 +706,7 @@ class UniformReal(Primitive):
     """
     @prim_attr_register
     def __init__(self, seed=0, seed2=0):
-        """Initialize StandardNormal"""
+        """Initialize UniformReal"""
         self.init_prim_io_names(inputs=['shape'], outputs=['output'])
         self.add_prim_attr("side_effect_hidden", True)
         Validator.check_non_negative_int(seed, "seed", self.name)
@@ -640,15 +717,13 @@ class RandomChoiceWithMask(Primitive):
     """
     Generates a random sample as index tensor with a mask tensor from a given tensor.
 
-    The input must be a tensor of rank not less than 1. If its rank is greater than or equal to 2,
-    the first dimension specifies the number of samples.
-    The index tensor and the mask tensor have the fixed shapes. The index tensor denotes the index of the nonzero
-    sample, while the mask tensor denotes which elements in the index tensor are valid.
+    Refer to :func:`mindspore.ops.choice_with_mask` for more details.
 
     Args:
-        count (int): Number of items expected to get and the number must be greater than 0. Default: 256.
-        seed (int): Random seed. Default: 0.
-        seed2 (int): Random seed2. Default: 0.
+        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.
@@ -660,11 +735,6 @@ class RandomChoiceWithMask(Primitive):
         - **index** (Tensor) - The output shape is 2-D.
         - **mask** (Tensor) - The output shape is 1-D.
 
-    Raises:
-        TypeError: If `count` is not an int.
-        TypeError: If neither `seed` nor `seed2` is an int.
-        TypeError: If `input_x` is not a Tensor.
-
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -691,7 +761,7 @@ class RandomChoiceWithMask(Primitive):
 
 
 class RandomCategorical(PrimitiveWithInfer):
-    """
+    r"""
     Generates random samples from a given categorical distribution tensor.
 
     Args:
@@ -699,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.
@@ -759,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:
@@ -768,9 +837,9 @@ 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.
+        TypeError: If `dtype` is not int32 or int64.
+        ValueError: If `seed` or `seed2` is less than 0.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -779,7 +848,7 @@ class Multinomial(Primitive):
         >>> 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]]
     """
 
@@ -788,20 +857,72 @@ class Multinomial(Primitive):
         """Initialize Multinomial."""
         Validator.check_non_negative_int(seed, "seed", self.name)
         Validator.check_non_negative_int(seed2, "seed2", self.name)
-        self.init_prim_io_names(inputs=['x', 'num_samples'], outputs=['output'])
+        self.init_prim_io_names(
+            inputs=['x', 'num_samples'], outputs=['output'])
         Validator.check_value_type("dtype", dtype, [mstype.Type], self.name)
         valid_values = (mstype.int64, mstype.int32)
         Validator.check_type_name("dtype", dtype, valid_values, self.name)
         self.add_prim_attr("side_effect_hidden", True)
 
 
-class UniformCandidateSampler(PrimitiveWithInfer):
+class MultinomialWithReplacement(Primitive):
+    r"""
+    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.
+
+    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:
+        ``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, seed, offset)
+        >>> print(output)
+        [[1 1]]
+    """
+
+    @prim_attr_register
+    def __init__(self, numsamples, replacement=False):
+        """Initialize MultinomialWithReplacement."""
+        Validator.check_non_negative_int(numsamples, "numsamples", self.name)
+        Validator.check_value_type("replacement", replacement, [bool], self.name)
+        self.init_prim_io_names(inputs=['x', 'seed', 'offset'], outputs=['y'])
+        self.add_prim_attr("side_effect_hidden", True)
+
+
+class UniformCandidateSampler(Primitive):
     r"""
     Uniform candidate sampler.
 
     This function samples a set of classes(sampled_candidates) from [0, range_max-1] based on uniform distribution.
 
-    Refer to :func:`mindspore.ops.uniform_candidate_sampler` for more detail.
+    Refer to :func:`mindspore.ops.uniform_candidate_sampler` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -821,66 +942,39 @@ class UniformCandidateSampler(PrimitiveWithInfer):
     def __init__(self, num_true, num_sampled, unique, range_max, seed=0, remove_accidental_hits=False):
         """Initialize UniformCandidateSampler"""
         Validator.check_value_type("num_true", num_true, [int], self.name)
-        Validator.check_value_type("num_sampled", num_sampled, [int], self.name)
+        Validator.check_value_type(
+            "num_sampled", num_sampled, [int], self.name)
         Validator.check_value_type("unique", unique, [bool], self.name)
         Validator.check_value_type("range_max", range_max, [int], self.name)
         Validator.check_value_type("seed", seed, [int], self.name)
-        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)
-        Validator.check("value of num_sampled", num_sampled, '', 0, Rel.GT, self.name)
-        Validator.check("value of range_max", range_max, '', 0, Rel.GT, self.name)
+        Validator.check_value_type(
+            "remove_accidental_hits", remove_accidental_hits, [bool], self.name)
+        Validator.check("value of num_true", num_true,
+                        '', 0, Validator.GT, self.name)
+        Validator.check("value of num_sampled", num_sampled,
+                        '', 0, Validator.GT, self.name)
+        Validator.check("value of range_max", range_max,
+                        '', 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)
+            Validator.check('value of num_sampled', num_sampled,
+                            "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(PrimitiveWithInfer):
+class LogUniformCandidateSampler(Primitive):
     r"""
     Generates random labels with a log-uniform distribution for sampled_candidates.
 
     Randomly samples a tensor of sampled classes from the range of integers [0, range_max).
 
-    Args:
-        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.
-
-    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.
-
-    Raises:
-        TypeError: If neither `num_true` nor `num_sampled` is an int.
-        TypeError: If `unique` is not a bool.
-        TypeError: If neither `range_max` nor `seed` is an int.
-        TypeError: If `true_classes` is not a Tensor.
+    Refer to :func:`mindspore.ops.log_uniform_candidate_sampler` for more details.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``CPU``
 
     Examples:
         >>> sampler = ops.LogUniformCandidateSampler(2, 5, True, 5)
@@ -900,30 +994,23 @@ class LogUniformCandidateSampler(PrimitiveWithInfer):
         self.init_prim_io_names(inputs=['true_classes'],
                                 outputs=['sampled_candidates', 'true_expected_count', 'sampled_expected_count'])
         Validator.check_value_type("num_true", num_true, [int], self.name)
-        Validator.check_value_type("num_sampled", num_sampled, [int], self.name)
+        Validator.check_value_type(
+            "num_sampled", num_sampled, [int], self.name)
         Validator.check_value_type("unique", unique, [bool], self.name)
         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)
-        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)
+        self.num_true = Validator.check_number(
+            "num_true", num_true, 1, Validator.GE, self.name)
+        self.num_sampled = Validator.check_number(
+            "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)
+            Validator.check("range_max", range_max, "num_sampled",
+                            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)
-
-    def infer_shape(self, true_classes_shape):
-        Validator.check_int(len(true_classes_shape), 2, Rel.EQ, "dim of true_classes", self.name)
-        Validator.check("true_classes_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,)
-
-    def infer_dtype(self, true_classes_type):
-        Validator.check_subclass("true_classes_type", true_classes_type, mstype.tensor, self.name)
-        valid_types = (mstype.int64,)
-        Validator.check_tensor_dtype_valid("true_classes_type", true_classes_type, valid_types, self.name)
-        expected_type = mstype.float32
-        return true_classes_type, expected_type, expected_type
+        self.seed = Validator.check_number("seed", seed, 0, Validator.GE, self.name)
+        self.add_prim_attr("side_effect_hidden", True)
 
 
 class RandomShuffle(Primitive):
@@ -931,9 +1018,11 @@ class RandomShuffle(Primitive):
     Randomly shuffles a Tensor along its first dimension.
 
     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): 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:
         - **x** (Tensor) - The Tensor need be shuffled.
@@ -945,7 +1034,7 @@ class RandomShuffle(Primitive):
         TypeError: If data type of `seed` or `seed2` is not int.
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([1, 2, 3, 4]), mstype.float32)
@@ -959,5 +1048,83 @@ class RandomShuffle(Primitive):
     def __init__(self, seed=0, seed2=0):
         """Initialize RandomShuffle"""
         self.init_prim_io_names(inputs=['input_x'], outputs=['output'])
+        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)