mindspore 2.3.0__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/ops/function/other_func.py

@@ -37,7 +37,7 @@ def partial(func, *args):
 
     Examples:
         >>> from mindspore import Tensor
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> def show_input(x, y, z):
         ...     return x, y, z
         >>> partial_show_input = ops.partial(show_input, Tensor(1))
@@ -81,7 +81,7 @@ def depend(value, expr):
         >>> import numpy as np
         >>> import mindspore
         >>> import mindspore.nn as nn
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> class Net(nn.Cell):
         ...     def __init__(self):

mindspore/ops/function/random_func.py

@@ -28,14 +28,10 @@ from mindspore.common.tensor import Tensor
 from mindspore.ops.operations.random_ops import RandomShuffle, RandomChoiceWithMask
 from mindspore.common.api import _function_forbid_reuse
 from mindspore.ops.auto_generate import randperm
-from mindspore.common.generator import default_generator
-from mindspore.ops.auto_generate import UniformExt, NormalTensorTensor, \
-    NormalTensorFloat, NormalFloatTensor, NormalFloatFloat, RandExt, RandLikeExt
-
-normal_tensor_tensor_op = NormalTensorTensor()
-normal_tensor_float_op = NormalTensorFloat()
-normal_float_tensor_op = NormalFloatTensor()
-normal_float_float_op = NormalFloatFloat()
+from mindspore.nn.generator import default_generator
+from mindspore.ops.auto_generate import UniformExt, NormalExt
+
+normal_ext_op = NormalExt()
 cast_ = P.Cast()
 log_ = P.Log()
 real_div_ = P.RealDiv()
@@ -43,10 +39,6 @@ reshape_ = P.Reshape()
 shape_ = P.Shape()
 top_k_ = P.TopK()
 uniform_ = UniformExt()
-rand_ext_ = RandExt()
-rand_like_ext_ = RandLikeExt()
-generator_step_ = Tensor(10, mstype.int64)
-
 
 @constexpr
 def _set_prim_op_user_data(prim, key, value):
@@ -95,8 +87,7 @@ def random_gamma(shape, alpha, seed=None):
     """
     seed1, seed2 = _get_seed(seed, "random_gamma")
     random_gamma_op = P.RandomGamma(seed1, seed2)
-    random_gamma_op = _set_prim_op_user_data(
-        random_gamma_op, "random_cache", False)
+    random_gamma_op = _set_prim_op_user_data(random_gamma_op, "random_cache", False)
     output = random_gamma_op(shape, alpha)
     return output
 
@@ -143,8 +134,7 @@ def standard_laplace(shape, seed=None):
     """
     seed1, seed2 = _get_seed(seed, "standard_laplace")
     standard_laplace_op = P.StandardLaplace(seed=seed1, seed2=seed2)
-    standard_laplace_op = _set_prim_op_user_data(
-        standard_laplace_op, "random_cache", False)
+    standard_laplace_op = _set_prim_op_user_data(standard_laplace_op, "random_cache", False)
     return standard_laplace_op(shape)
 
 
@@ -183,8 +173,7 @@ def random_categorical(logits, num_sample, seed=0, dtype=mstype.int64):
         (10, 8)
     """
     random_categorical_ = P.RandomCategorical(dtype)
-    random_categorical_ = _set_prim_op_user_data(
-        random_categorical_, "random_cache", False)
+    random_categorical_ = _set_prim_op_user_data(random_categorical_, "random_cache", False)
     return random_categorical_(logits, num_sample, seed)
 
 
@@ -244,8 +233,7 @@ def multinomial_with_replacement(x, seed, offset, numsamples, replacement=False)
         offset = Tensor(offset, dtype=mstype.int64)
     multinomial_with_replacement_ = P.MultinomialWithReplacement(numsamples=numsamples,
                                                                  replacement=replacement)
-    multinomial_with_replacement_ = _set_prim_op_user_data(
-        multinomial_with_replacement_, "random_cache", False)
+    multinomial_with_replacement_ = _set_prim_op_user_data(multinomial_with_replacement_, "random_cache", False)
     return multinomial_with_replacement_(x, seed, offset)
 
 
@@ -256,8 +244,8 @@ def uniform_ext(tensor, a, b, generator=None):
 
     Args:
         tensor (Tensor): The origin input tensor.
-        a (number): The lower bound of the interval.
-        b (number): The upper bound of the interval.
+        a (float): The lower bound of the interval.
+        b (float): The upper bound of the interval.
         generator (Generator, optional): The random seed. Default: None.
 
     Raises:
@@ -267,18 +255,16 @@ def uniform_ext(tensor, a, b, generator=None):
         Tensor, with the same shape as tensor.
 
     Examples:
+        >>> from mindspore import Tensor, ops
         >>> import mindspore
-        >>> from mindspore import ops
-        >>> x = ops.ones((4, 2))
-        >>> generator = mindspore.Generator()
-        >>> generator.manual_seed(100)
-        >>> result = ops.function.random_func.uniform_ext(x, 1., 2., generator)
-        >>> print(result.shape)
-        (4, 2)
+        >>> import numpy as np
+        >>> x = mindspore.ops.ones(4, 2)
+        >>> output = ops.uniform_ext(x, 1., 2.)
+        >>> print(result)
     """
     if generator is None:
-        generator = default_generator
-    seed, offset = generator._step(generator_step_)  # pylint: disable=protected-access
+        generator = default_generator()
+    seed, offset = generator(1)
     return uniform_(tensor, a, b, seed, offset)
 
 
@@ -339,25 +325,21 @@ def uniform(shape, minval, maxval, seed=None, dtype=mstype.float32):
         (3, 2, 2)
     """
     if not isinstance(minval, Tensor) or not isinstance(maxval, Tensor):
-        raise TypeError(
-            f"For functional operator[uniform], the input[minval] and input[maxval] must be a Tensor.")
+        raise TypeError(f"For functional operator[uniform], the input[minval] and input[maxval] must be a Tensor.")
 
     minval_dtype = F.dtype(minval)
     maxval_dtype = F.dtype(maxval)
-    const_utils.check_type_valid(
-        dtype, [mstype.int32, mstype.float32], 'uniform')
+    const_utils.check_type_valid(dtype, [mstype.int32, mstype.float32], 'uniform')
     const_utils.check_tensors_dtype_same(minval_dtype, dtype, "uniform")
     const_utils.check_tensors_dtype_same(maxval_dtype, dtype, "uniform")
     seed1, seed2 = _get_seed(seed, "uniform")
     if const_utils.is_same_type(dtype, mstype.int32):
         random_uniform = P.UniformInt(seed1, seed2)
-        random_uniform = _set_prim_op_user_data(
-            random_uniform, "random_cache", False)
+        random_uniform = _set_prim_op_user_data(random_uniform, "random_cache", False)
         value = random_uniform(shape, minval, maxval)
     else:
         uniform_real = P.UniformReal(seed1, seed2)
-        uniform_real = _set_prim_op_user_data(
-            uniform_real, "random_cache", False)
+        uniform_real = _set_prim_op_user_data(uniform_real, "random_cache", False)
         uniform_real = uniform_real(shape)
         value = uniform_real * (maxval - minval) + minval
     return value
@@ -400,8 +382,7 @@ def standard_normal(shape, seed=None):
     """
     seed1, seed2 = _get_seed(seed, "standard_normal")
     standard_normal_op = P.StandardNormal(seed=seed1, seed2=seed2)
-    standard_normal_op = _set_prim_op_user_data(
-        standard_normal_op, "random_cache", False)
+    standard_normal_op = _set_prim_op_user_data(standard_normal_op, "random_cache", False)
     return standard_normal_op(shape)
 
 
@@ -468,8 +449,7 @@ def uniform_candidate_sampler(true_classes,
                                            seed=seed,
                                            remove_accidental_hits=remove_accidental_hits)
     sampler_op = _set_prim_op_user_data(sampler_op, "random_cache", False)
-    sampled_candidates, true_expected_count, sampled_expected_count = sampler_op(
-        true_classes)
+    sampled_candidates, true_expected_count, sampled_expected_count = sampler_op(true_classes)
     return sampled_candidates, true_expected_count, sampled_expected_count
 
 
@@ -533,8 +513,7 @@ def random_poisson(shape, rate, seed=None, dtype=mstype.float32):
     """
     seed1, seed2 = _get_seed(seed, "random_poisson")
     prim_random_poisson = P.RandomPoisson(seed1, seed2, dtype)
-    prim_random_poisson = _set_prim_op_user_data(
-        prim_random_poisson, "random_cache", False)
+    prim_random_poisson = _set_prim_op_user_data(prim_random_poisson, "random_cache", False)
     value = prim_random_poisson(shape, rate)
     return value
 
@@ -569,8 +548,7 @@ def shuffle(x, seed=None):
     """
     seed, seed2 = _get_seed(seed, "shuffle")
     random_shuffle_ = RandomShuffle(seed=seed, seed2=seed2)
-    random_shuffle_ = _set_prim_op_user_data(
-        random_shuffle_, "random_cache", False)
+    random_shuffle_ = _set_prim_op_user_data(random_shuffle_, "random_cache", False)
     output = random_shuffle_(x)
     return output
 
@@ -624,8 +602,7 @@ def log_uniform_candidate_sampler(true_classes, num_true=1, num_sampled=5, uniqu
 
     """
 
-    sampler = P.LogUniformCandidateSampler(
-        num_true, num_sampled, unique, range_max, seed)
+    sampler = P.LogUniformCandidateSampler(num_true, num_sampled, unique, range_max, seed)
     sampler = _set_prim_op_user_data(sampler, "random_cache", False)
     return sampler(true_classes)
 
@@ -664,7 +641,7 @@ def choice_with_mask(input_x, count=256, seed=None):
     Examples:
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> input_x = Tensor(np.ones(shape=[240000, 4]).astype(np.bool_))
+        >>> input_x = Tensor(np.ones(shape=[240000, 4]).astype(np.bool))
         >>> output_y, output_mask = ops.choice_with_mask(input_x)
         >>> result = output_y.shape
         >>> print(result)
@@ -674,10 +651,8 @@ def choice_with_mask(input_x, count=256, seed=None):
         (256,)
     """
     seed1, seed2 = _get_seed(seed, "choice_with_mask")
-    choice_with_mask_ = RandomChoiceWithMask(
-        count=count, seed=seed1, seed2=seed2)
-    choice_with_mask_ = _set_prim_op_user_data(
-        choice_with_mask_, "random_cache", False)
+    choice_with_mask_ = RandomChoiceWithMask(count=count, seed=seed1, seed2=seed2)
+    choice_with_mask_ = _set_prim_op_user_data(choice_with_mask_, "random_cache", False)
     output = choice_with_mask_(input_x)
     return output
 
@@ -687,23 +662,18 @@ def is_cpu_backend():
     """Check if the CPU is used"""
     return context.get_context('device_target') == 'CPU'
 
-
-def normal_ext(mean=0.0, std=1.0, size=None, generator=None):
+def normal_ext(mean, std, generator=None):
     r"""
     Generates random numbers according to the standard Normal (or Gaussian) random number distribution.
 
     Args:
-        mean (Union[float, Tensor], optional): Mean value of each element, the shape of the 'mean' tensor
-            should be the same as that of the 'std' tensor. Default: ``0.0``.
-        std (Union[float, Tensor], optional): Standard deviation for each element, the shape of the 'std' tensor
-            should be the same as that of the 'mean' tensor. The value of std should be greater than or equal to 0.
-            Default: ``1.0``.
-        size (tuple, optional): output size, where 'mean' and 'std' are constants. Default: ``None``.
-        generator (generator, optional): MindSpore generator. Default: ``None``.
+        - **mean** (Union[float, Tensor]) - The mean is a tensor with the mean of each output
+          element's normal distribution.
+        - **std** (Union[float, Tensor]) - The tensor of per-element standard deviations.
+        - **generator** (Generator, optional) - Mindspore generator.
 
     Returns:
-        Outputs a tensor with the same shape as 'mean',
-        or when 'mean' and 'std' are constants and shape is specified as 'size'.
+        - **output** (Tensor) - With the same type and shape as the 'mean'.
 
     Raises:
         TypeError: If `mean` or `std` is not Union[float, Tensor].
@@ -714,28 +684,18 @@ def normal_ext(mean=0.0, std=1.0, size=None, generator=None):
     Examples:
         >>> import mindspore
         >>> import numpy as np
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> mean = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
         >>> std = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
-        >>> output = ops.function.random_func.normal_ext(mean, std)
+        >>> output = ops.normal_ext(mean, std)
         >>> print(output.shape)
         (3,)
     """
     if generator is None:
-        generator = default_generator
-    seed, offset = generator._step(generator_step_)  # pylint: disable=protected-access
-
-    is_mean_tensor = isinstance(mean, Tensor)
-    is_std_tensor = isinstance(std, Tensor)
-
-    if is_mean_tensor and is_std_tensor:
-        return normal_tensor_tensor_op(mean, std, seed, offset)
-    if is_mean_tensor and not is_std_tensor:
-        return normal_tensor_float_op(mean, std, seed, offset)
-    if not is_mean_tensor and is_std_tensor:
-        return normal_float_tensor_op(mean, std, seed, offset)
-    return normal_float_float_op(mean, std, size, seed, offset)
+        generator = default_generator()
+    seed, offset = generator(1)
+    return normal_ext_op(mean, std, seed, offset)
 
 
 @_function_forbid_reuse
@@ -840,8 +800,7 @@ def laplace(shape, mean, lambda_param, seed=None):
     mean_dtype = F.dtype(mean)
     lambda_param_dtype = F.dtype(lambda_param)
     const_utils.check_tensors_dtype_same(mean_dtype, mstype.float32, "laplace")
-    const_utils.check_tensors_dtype_same(
-        lambda_param_dtype, mstype.float32, "laplace")
+    const_utils.check_tensors_dtype_same(lambda_param_dtype, mstype.float32, "laplace")
     seed1, seed2 = _get_seed(seed, "laplace")
     stdlaplace = P.StandardLaplace(seed1, seed2)
     stdlaplace = _set_prim_op_user_data(stdlaplace, "random_cache", False)
@@ -979,7 +938,7 @@ def rand(*size, dtype=None, seed=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> print(ops.rand((2,3)))
         [[4.1702199e-01 9.9718481e-01 7.2032452e-01]
          [9.3255734e-01 1.1438108e-04 1.2812445e-01]]
@@ -987,8 +946,7 @@ def rand(*size, dtype=None, seed=None):
     if dtype is None:
         dtype = mstype.float32
     elif dtype not in mstype.float_type:
-        raise ValueError(
-            f"For 'rand', the 'dtype' must be a float type, but got {dtype}.")
+        raise ValueError(f"For 'rand', the 'dtype' must be a float type, but got {dtype}.")
     shape = _generate_shapes(size)
     seed1, seed2 = _get_seed(seed, 'rand')
     rand_op = P.UniformReal(seed1, seed2)
@@ -1031,13 +989,11 @@ def rand_like(input, seed=None, *, dtype=None):
          [9.3255734e-01 1.1438108e-04 1.2812445e-01]]
     """
     if not isinstance(input, Tensor):
-        raise TypeError(
-            f"For 'rand_like', the 'input' must be a Tensor, but got {type(input)}")
+        raise TypeError(f"For 'rand_like', the 'input' must be a Tensor, but got {type(input)}")
     if dtype is None:
         dtype = input.dtype
     if dtype not in mstype.float_type:
-        raise ValueError(
-            f"For 'rand_like', the 'dtype' must be a float type, but got {dtype}.")
+        raise ValueError(f"For 'rand_like', the 'dtype' must be a float type, but got {dtype}.")
     shape = input.shape
     seed1, seed2 = _get_seed(seed, 'rand_like')
     rand_op = P.UniformReal(seed1, seed2)
@@ -1046,76 +1002,6 @@ def rand_like(input, seed=None, *, dtype=None):
     return cast_(output, dtype)
 
 
-@_function_forbid_reuse
-def rand_ext(*size, generator=None, dtype=None):
-    r"""
-    Returns a new tensor that fills numbers from the uniform distribution over an interval :math:`[0, 1)`
-    based on the given shape and dtype.
-
-    Args:
-        size (Union[int, tuple(int), list(int)]): Shape of the new tensor, e.g. :math:`(2, 3)` or :math:`2`.
-
-    Keyword Args:
-        generator (:class:`mindspore.Generator`, optional): a pseudorandom number generator.
-            Default: ``None``, uses the default pseudorandom number generator.
-        dtype (:class:`mindspore.dtype`, optional): Designated tensor dtype, it must be float type. If None,
-            `mindspore.float32` will be applied. Default: ``None`` .
-
-    Returns:
-        Tensor, with the designated shape and dtype, filled with random numbers from the uniform distribution on
-        the interval :math:`[0, 1)`.
-
-    Raises:
-        ValueError: If `dtype` is not a `mstype.float_type` type.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore.ops as ops
-        >>> print(ops.function.random_func.rand_ext(2, 3).shape)
-        (2, 3)
-    """
-    if not generator:
-        generator = default_generator
-    seed, offset = generator._step(generator_step_)  # pylint: disable=protected-access
-    return rand_ext_(size, seed, offset, dtype)
-
-
-@_function_forbid_reuse
-def rand_like_ext(input, *, dtype=None):
-    r"""
-    Returns a new tensor that fills numbers from the uniform distribution over an interval :math:`[0, 1)`
-    based on the given dtype and shape of the input tensor.
-
-    Args:
-        input (Tensor): Input Tensor to specify the output shape and its default dtype.
-
-    Keyword Args:
-        dtype (:class:`mindspore.dtype`, optional): Designated tensor dtype, it must be float type. If None,
-            the same dtype of `input` will be applied. Default: ``None`` .
-
-    Returns:
-        Tensor, with the designated shape and dtype, filled with random numbers from the uniform distribution on
-        the interval :math:`[0, 1)`.
-
-    Raises:
-        ValueError: If `dtype` is not a `mstype.float_type` type.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore as ms
-        >>> from mindspore import Tensor, ops
-        >>> a = Tensor([[2, 3, 4], [1, 2, 3]])
-        >>> print(ops.function.random_func.rand_like_ext(a, dtype=ms.float32).shape)
-        (2, 3)
-    """
-    seed, offset = default_generator._step(generator_step_)  # pylint: disable=protected-access
-    return rand_like_ext_(input, seed, offset, dtype)
-
-
 @_function_forbid_reuse
 def randn(*size, dtype=None, seed=None):
     r"""
@@ -1143,7 +1029,7 @@ def randn(*size, dtype=None, seed=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> print(ops.randn((2, 2)))
         [[ 0.30639967 -0.42438635]
          [-0.4287376   1.3054721 ]]
@@ -1151,8 +1037,7 @@ def randn(*size, dtype=None, seed=None):
     if dtype is None:
         dtype = mstype.float32
     elif dtype not in mstype.float_type:
-        raise ValueError(
-            f"For 'randn', the 'dtype' must be a float type, but got {dtype}.")
+        raise ValueError(f"For 'randn', the 'dtype' must be a float type, but got {dtype}.")
     shape = _generate_shapes(size)
     seed1, seed2 = _get_seed(seed, 'randn')
     rand_op = P.StandardNormal(seed1, seed2)
@@ -1195,13 +1080,11 @@ def randn_like(input, seed=None, *, dtype=None):
          [-0.4287376   1.3054721   0.64747655]]
     """
     if not isinstance(input, Tensor):
-        raise TypeError(
-            f"For 'randn_like', the 'input' must be a Tensor, but got {type(input)}")
+        raise TypeError(f"For 'randn_like', the 'input' must be a Tensor, but got {type(input)}")
     if dtype is None:
         dtype = mstype.float32
     if dtype not in mstype.float_type:
-        raise ValueError(
-            f"For 'randn_like', the 'dtype' must be a float type, but got {dtype}.")
+        raise ValueError(f"For 'randn_like', the 'dtype' must be a float type, but got {dtype}.")
     shape = input.shape
     seed1, seed2 = _get_seed(seed, 'randn_like')
     rand_op = P.StandardNormal(seed1, seed2)
@@ -1240,7 +1123,7 @@ def randint(low, high, size, seed=None, *, dtype=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> print(ops.randint(1, 10, (2,3)))
         [[4 9 7]
          [9 1 2]]
@@ -1248,17 +1131,13 @@ def randint(low, high, size, seed=None, *, dtype=None):
     if dtype is None:
         dtype = mstype.int64
     elif dtype not in mstype.int_type:
-        raise ValueError(
-            f"For 'randint', the 'dtype' must be an int type, but got {dtype}.")
+        raise ValueError(f"For 'randint', the 'dtype' must be an int type, but got {dtype}.")
     if not isinstance(size, tuple):
-        raise ValueError(
-            f"For 'randint', the input 'size' must be a tuple, but got {size}.")
+        raise ValueError(f"For 'randint', the input 'size' must be a tuple, but got {size}.")
     if not isinstance(low, int) or isinstance(low, bool):
-        raise TypeError(
-            f"For 'randint_like', 'low' must be an int, but got {type(low)}.")
+        raise TypeError(f"For 'randint_like', 'low' must be an int, but got {type(low)}.")
     if not isinstance(high, int) or isinstance(high, bool):
-        raise TypeError(
-            f"For 'randint_like', 'high' must be an int, but got {type(high)}.")
+        raise TypeError(f"For 'randint_like', 'high' must be an int, but got {type(high)}.")
     seed1, seed2 = _get_seed(seed, 'randint')
     rand_op = P.UniformInt(seed1, seed2)
     rand_op = _set_prim_op_user_data(rand_op, "random_cache", False)
@@ -1304,19 +1183,15 @@ def randint_like(input, low, high, seed=None, *, dtype=None):
         [9 1 2]]
     """
     if not isinstance(input, Tensor):
-        raise TypeError(
-            f"For 'randint_like', the 'input' must be a Tensor, but got {type(input)}")
+        raise TypeError(f"For 'randint_like', the 'input' must be a Tensor, but got {type(input)}")
     if dtype is None:
         dtype = input.dtype
     if dtype not in mstype.int_type:
-        raise ValueError(
-            f"For 'randint_like', the 'dtype' must be an int type, but got {dtype}.")
+        raise ValueError(f"For 'randint_like', the 'dtype' must be an int type, but got {dtype}.")
     if not isinstance(low, int) or isinstance(low, bool):
-        raise TypeError(
-            f"For 'randint_like', 'low' must be an int, but got {type(low)}.")
+        raise TypeError(f"For 'randint_like', 'low' must be an int, but got {type(low)}.")
     if not isinstance(high, int) or isinstance(high, bool):
-        raise TypeError(
-            f"For 'randint_like', 'high' must be an int, but got {type(high)}.")
+        raise TypeError(f"For 'randint_like', 'high' must be an int, but got {type(high)}.")
     size = input.shape
     seed1, seed2 = _get_seed(seed, 'randint_like')
     rand_op = P.UniformInt(seed1, seed2)
@@ -1377,8 +1252,7 @@ def poisson(shape, mean, seed=None):
     """
     seed1, seed2 = _get_seed(seed, "poisson")
     random_poisson_op = P.Poisson(seed1, seed2)
-    random_poisson_op = _set_prim_op_user_data(
-        random_poisson_op, "random_cache", False)
+    random_poisson_op = _set_prim_op_user_data(random_poisson_op, "random_cache", False)
     value = random_poisson_op(shape, mean)
     return value
 
@@ -1475,8 +1349,7 @@ def multinomial(input, num_samples, replacement=True, seed=None):
     """
     def _check_valid_dim(dim, name):
         if dim not in (1, 2):
-            raise ValueError(
-                f"For '{name}', the dimension of inputs must be 1d or 2d, but got {dim}.")
+            raise ValueError(f"For '{name}', the dimension of inputs must be 1d or 2d, but got {dim}.")
 
     _check_valid_dim(len(shape_(input)), "multinomial")
     seed1, seed2 = _get_seed(seed, "multinomial")
@@ -1490,34 +1363,29 @@ def multinomial(input, num_samples, replacement=True, seed=None):
         if len(shape_(input)) > 1:
             n_dist = shape_(input)[-2]
         random_uniform_real = P.UniformReal(seed1, seed2)
-        random_cache_op = _set_prim_op_user_data(
-            random_uniform_real, "random_cache", False)
+        random_cache_op = _set_prim_op_user_data(random_uniform_real, "random_cache", False)
         random_uniform = random_cache_op((n_dist * shape_(input)[-1],))
         if n_dist != 1:
-            random_uniform = reshape_(
-                random_uniform, (n_dist, shape_(input)[-1]))
+            random_uniform = reshape_(random_uniform, (n_dist, shape_(input)[-1]))
+
 
         vals = real_div_(log_(random_uniform), input + 1e-6)
         _, indices = top_k_(vals, num_samples)
         return indices
     random_nomial = P.Multinomial(seed1, seed2)
-    random_nomial = _set_prim_op_user_data(
-        random_nomial, "random_cache", False)
+    random_nomial = _set_prim_op_user_data(random_nomial, "random_cache", False)
     return random_nomial(input, num_samples)
 
 
 def _check_shape(input_shape):
     """Check 'shape' value."""
     if not isinstance(input_shape, tuple):
-        const_utils.raise_type_error(
-            f"Type of 'shape' must be tuple, but got: {type(input_shape)}")
+        const_utils.raise_type_error(f"Type of 'shape' must be tuple, but got: {type(input_shape)}")
     for item in input_shape:
         if not isinstance(item, int):
-            const_utils.raise_type_error(
-                f"Elements of 'shape' must be int, but got: {type(item)}")
+            const_utils.raise_type_error(f"Elements of 'shape' must be int, but got: {type(item)}")
         if item < 1:
-            const_utils.raise_value_error(
-                f"Elements of 'shape' must be positive int, but got: {item}")
+            const_utils.raise_value_error(f"Elements of 'shape' must be positive int, but got: {item}")
     return True
 
 
@@ -1530,10 +1398,9 @@ def _check_param(op_name, param_name, param_value):
 
 
 __all__ = [
-    'standard_laplace', 'random_categorical', 'uniform', 'standard_normal', 'random_gamma',
+    'standard_laplace', 'random_categorical', 'uniform', 'uniform_ext', 'standard_normal', 'random_gamma',
     'uniform_candidate_sampler', 'random_poisson', 'log_uniform_candidate_sampler', 'shuffle', 'choice_with_mask',
-    'normal', 'laplace', 'gamma', 'poisson', 'multinomial', 'rand', 'rand_like',
-    'randn', 'randn_like',
+    'normal_ext', 'normal', 'laplace', 'gamma', 'poisson', 'multinomial', 'rand', 'rand_like', 'randn', 'randn_like',
     'randint', 'randint_like', 'multinomial_with_replacement', 'randperm'
 ]
 __all__.sort()

mindspore/ops/function/sparse_func.py

@@ -140,7 +140,7 @@ def coalesce(x_indices: Tensor, x_values: Tensor, x_shape: Tensor) -> Tuple[Tens
 
     Examples:
         >>> import mindspore
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> x_indices = Tensor([[0, 0, 1], [1, 1, 2]], dtype=ms.int64)
         >>> x_values = Tensor([1, 5, 4], dtype=ms.float32)
@@ -271,7 +271,7 @@ def csr_mm(a: CSRTensor, b: CSRTensor, trans_a: bool = False, trans_b: bool = Fa
     Examples:
         >>> from mindspore import Tensor, CSRTensor
         >>> from mindspore import dtype as mstype
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> a_shape = (4, 5)
         >>> a_indptr = Tensor([0, 1, 1, 3, 4], dtype=mstype.int32)
         >>> a_indices = Tensor([0, 3, 4, 0],dtype=mstype.int32)
@@ -745,7 +745,7 @@ def csr_softmax(logits: CSRTensor, dtype: mstype):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> import mindspore.common.dtype as mstype
         >>> from mindspore import Tensor, CSRTensor
         >>> logits_indptr = Tensor([0, 4, 6], dtype=mstype.int32)
@@ -807,7 +807,7 @@ def csr_add(a: CSRTensor, b: CSRTensor, alpha: Tensor, beta: Tensor) -> CSRTenso
     Examples:
         >>> import mindspore.common.dtype as mstype
         >>> from mindspore import Tensor, CSRTensor
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> a_indptr = Tensor([0, 1, 2], dtype=mstype.int32)
         >>> a_indices = Tensor([0, 1], dtype=mstype.int32)
         >>> a_values = Tensor([1, 2], dtype=mstype.float32)