mindspore 2.4.10__cp310-cp310-manylinux1_x86_64.whl → 2.5.0__cp310-cp310-manylinux1_x86_64.whl

mindspore/ops/function/parameter_func.py

@@ -17,68 +17,16 @@
 
 from mindspore.ops import operations as P
 from mindspore.ops._primitive_cache import _get_cache_prim
-from mindspore.ops.auto_generate import assign, assign_add
-
-
-assign_sub_ = P.AssignSub()
-assign_add_ = P.AssignAdd()
-
-
-def assign_sub(variable, value):
-    """
-    Updates a `Parameter` by subtracting a value from it.
-
-    Args of `variable` and `value` comply with the implicit type conversion rules to make the data types consistent.
-    If they have different data types, the lower priority data type will be converted to
-    the relatively highest priority data type.
-    If `value` is a number, the number is automatically converted to Tensor,
-    and the data type is consistent with the Tensor data type involved in the operation.
-
-    Note:
-        Since `variable` is a data type Parameter, the data type cannot be changed,
-        so only the type of `value` is allowed to be promoted to the type of `variable`.
-        And the conversion type supported by different devices will be different,
-        it is recommended to use the same data type when using this operator.
-
-    Args:
-        variable (Parameter): The `Parameter`.
-            :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
-        value (Tensor): The value to be subtracted from the `variable`.
-            It must have the same shape as `variable`.
-            it is recommended to use the same data type when using this operator.
-
-    Returns:
-        Tensor, has the same data type and shape as original `variable`.
-
-    Raises:
-        TypeError: If `value` is neither Number nor Tensor.
-        RuntimeError: If the data type of `x`, `y` conversion of Parameter is required
-                      when data type conversion of Parameter is not supported.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> from mindspore.common.initializer import initializer
-        >>> variable = mindspore.Parameter(initializer(1, [1], mindspore.int32), name="global_step")
-        >>> value = Tensor(np.ones([1]).astype(np.int32) * 100)
-        >>> ops.assign_sub(variable, value)
-        >>> print(variable.asnumpy())
-        [-99]
-    """
-    return assign_sub_(variable, value)
+from mindspore.ops.auto_generate import assign, assign_add, assign_sub
 
 
 def index_add(x, indices, y, axis, use_lock=True, check_index_bound=True):
     """
-    Adds tensor `y` to specified axis and indices of Parameter `x`. The axis should be in [0,  len(x.dim) - 1],
+    Adds tensor `y` to specified axis and indices of `x`. The axis should be in [0,  len(x.dim) - 1],
     and indices should be in [0, x.shape[axis] - 1] at the axis dimension.
 
     Args:
-        x (Parameter): The input Parameter to add to.
+        x (Union[Parameter, Tensor]): The input Parameter or Tensor to add to.
         indices (Tensor): Add the value of `x` and `y` along the dimension of the `axis` according to the
             specified index value, with data type int32.
             The `indices` must be 1D with the same size as the size of `y` in the `axis` dimension. The values
@@ -97,7 +45,6 @@ def index_add(x, indices, y, axis, use_lock=True, check_index_bound=True):
         Tensor, has the same shape and dtype as `x`.
 
     Raises:
-        TypeError: If `x` is not a Parameter.
         TypeError: If neither `indices` nor `y` is a Tensor.
         ValueError: If axis is out of `x` rank's range.
         ValueError: If `x` rank is not the same as `y` rank.

mindspore/ops/function/random_func.py

@@ -29,10 +29,11 @@ from mindspore.ops.operations.random_ops import RandomShuffle, RandomChoiceWithM
 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, \
+from mindspore.ops.auto_generate import UniformExt, InplaceUniform, NormalTensorTensor, \
     NormalTensorFloat, NormalFloatTensor, NormalFloatFloat, RandExt, RandLikeExt, MultinomialExt, \
-    Randn, RandnLike, RandInt, RandIntLike, RandpermExt
+    Randn, RandnLike, RandInt, RandIntLike, RandpermExt, InplaceRandom, InplaceNormal
 
+inplace_normal_ = InplaceNormal()
 normal_tensor_tensor_op = NormalTensorTensor()
 normal_tensor_float_op = NormalTensorFloat()
 normal_float_tensor_op = NormalFloatTensor()
@@ -44,7 +45,8 @@ reshape_ = P.Reshape()
 shape_ = P.Shape()
 top_k_ = P.TopK()
 randperm_ext_ = RandpermExt()
-uniform_ = UniformExt()
+uniform_ext_ = UniformExt()
+inplace_uniform_ = InplaceUniform()
 rand_ext_ = RandExt()
 rand_like_ext_ = RandLikeExt()
 multinomial_ext_ = MultinomialExt()
@@ -52,7 +54,8 @@ randn_ = Randn()
 randn_like_ = RandnLike()
 randint_ = RandInt()
 randint_like_ = RandIntLike()
-generator_step_ = Tensor(10, mstype.int64)
+inplace_random_ = InplaceRandom()
+generator_step_ = Tensor(12, mstype.int64)
 
 
 @constexpr
@@ -295,7 +298,58 @@ def uniform_ext(tensor, a, b, generator=None):
         generator = default_generator
     seed, offset = generator._step(  # pylint: disable=protected-access
         generator_step_)
-    return uniform_(tensor, a, b, seed, offset)
+    return uniform_ext_(tensor, a, b, seed, offset)
+
+
+@_function_forbid_reuse
+def uniform_(input, from_=0, to=1, *, generator=None):
+    r"""
+    Update the `input` tensor in place by generating random numbers sampled from uniform distribution in the half-open
+    interval :math:`[from\_, to)`.
+
+    .. math::
+        P(x)= \frac{1}{to - from\_}
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The origin input tensor.
+        from_ (Union[number.Number, Tensor], optional): The lower bound of the uniform distribution, it can be a scalar
+            value or a tensor of any dimension with a single element. Default: ``0``.
+        to (Union[number.Number, Tensor], optional): The upper bound of the uniform distribution, it can be a scalar
+            value or a tensor of any dimension with a single element. Default: ``1``.
+
+    Keyword Args:
+        generator (:class:`mindspore.Generator`, optional): a pseudorandom number generator.
+            Default: ``None``, uses the default pseudorandom number generator.
+
+    Returns:
+        Tensor, with the same shape and dtype as `input` tensor.
+
+   Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If dtype of `input` is not one of: bool, int8, int16, int32, int64, uint8, float16, float32, float64,
+            bfloat16.
+        TypeError: If `from_` or `to` is neither a number nor a Tensor.
+        TypeError: If dtype of `from` or `to` is not one of: bool, int8, int16, int32, int64, uint8, float32, float64.
+        ValueError: If `from_` or `to` is Tensor but contains multiple elements.
+        RuntimeError: If `from_` is larger than `to`.
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
+        >>> x = ops.ones((4, 2))
+        >>> generator = mindspore.Generator()
+        >>> generator.manual_seed(100)
+        >>> result = ops.function.random_func.uniform_(x, 1., 2., generator=generator)
+        >>> print(result.shape)
+        (4, 2)
+    """
+    if generator is None:
+        generator = default_generator
+    seed, offset = generator._step(generator_step_)  # pylint: disable=protected-access
+    return inplace_uniform_(input, from_, to, seed, offset)
 
 
 @_function_forbid_reuse
@@ -726,22 +780,69 @@ def is_cpu_backend():
     return context.get_context('device_target') == 'CPU'
 
 
+@_function_forbid_reuse
+def normal_(input, mean=0, std=1, *, generator=None):
+    r"""
+    Update the `input` tensor in place by generating random numbers sampled from the normal
+    distribution which constructed by the parameters `mean` and `std`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The origin input tensor.
+        mean (number, optional): the mean of normal distribution. With float data type.
+            Default: ``0``.
+        std (number, optional): the std of normal distribution. With float data type.
+            Default: ``1``.
+
+    Keyword Args:
+        generator (:class:`mindspore.Generator`, optional): a pseudorandom number generator.
+            Default: ``None``, uses the default pseudorandom number generator.
+
+    Returns:
+        A tensor that is filled with random numbers that follow a normal distribution and
+        that has the same type and shape as the `self` tensor.
+
+    Raises:
+        TypeError: If the dtype of `mean` or `std` is not one of: bool, int, float, complex.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> x = mindspore.Tensor(np.array([[1, 2], [3, 4]]), dtype=mindspore.float32)
+        >>> output = x.normal_()
+        >>> print(output)
+        [[0.2788825 1.3305743]
+         [1.244194 1.16303174]]
+    """
+    if generator is None:
+        generator = default_generator
+    seed, offset = generator._step(  # pylint: disable=protected-access
+        generator_step_)
+    return inplace_normal_(input, mean, std, seed, offset)
+
+
 def normal_ext(mean=0.0, std=1.0, size=None, generator=None):
     r"""
+    normal(mean, std, *, generator=None) -> Tensor
+
     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``.
+        mean (Union[float, Tensor]): Mean value of each element, the shape of the `mean` tensor
+            should be the same as that of the `std` tensor.
+        std (Union[float, Tensor]): 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.
+
+    Keyword Args:
         generator (generator, optional): MindSpore generator. Default: ``None``.
 
     Returns:
-        Outputs a tensor with the same shape as 'mean',
-        or when 'mean' and 'std' are constants and shape is specified as 'size'.
+        Outputs a tensor with the same shape as `mean`.
 
     Raises:
         TypeError: If `mean` or `std` is not Union[float, Tensor].
@@ -759,6 +860,58 @@ def normal_ext(mean=0.0, std=1.0, size=None, generator=None):
         >>> output = ops.function.random_func.normal_ext(mean, std)
         >>> print(output.shape)
         (3,)
+
+    .. function:: normal(mean, std=1.0) -> Tensor
+        :noindex:
+
+    Similar to the function above, but the standard deviations are shared among all drawn elements.
+
+    Args:
+        mean (Tensor): Mean value of each element.
+        std (float, optional): Standard deviation for each element. The value of `std` should be greater
+            than or equal to 0. Default: ``1.0``.
+
+    Returns:
+        Outputs a tensor with the same shape as `mean`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import ops
+        >>> from mindspore import Tensor
+        >>> mean = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
+        >>> output = ops.function.random_func.normal_ext(mean, 1.0)
+        >>> print(output.shape)
+        (3,)
+
+    .. function:: normal(mean, std, size) -> Tensor
+        :noindex:
+
+    Similar to the function above, but the means and standard deviations are shared among all drawn elements. The
+    result tensor has size given by `size`.
+
+    Args:
+        mean (float): Mean value of each element.
+        std (float): Standard deviation for each element.
+        size (tuple): output shape.
+
+    Returns:
+        Outputs a tensor. The shape is specified as `size`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import ops
+        >>> from mindspore import Tensor
+        >>> output = ops.function.random_func.normal_ext(1.0, 2.0, (2, 4))
+        >>> print(output.shape)
+        (2, 4)
     """
     if generator is None:
         generator = default_generator
@@ -1117,7 +1270,7 @@ def rand_ext(*size, generator=None, dtype=None):
     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,
+        dtype (:class:`mindspore.dtype`, optional): Designated tensor dtype. If None,
             `mindspore.float32` will be applied. Default: ``None`` .
 
     Returns:
@@ -1125,7 +1278,7 @@ def rand_ext(*size, generator=None, dtype=None):
         the interval :math:`[0, 1)`.
 
     Raises:
-        ValueError: If `dtype` is not a `mstype.float_type` type.
+        ValueError: If `size` contains negative numbers.
 
     Supported Platforms:
         ``Ascend``
@@ -1139,6 +1292,8 @@ def rand_ext(*size, generator=None, dtype=None):
         generator = default_generator
     seed, offset = generator._step(  # pylint: disable=protected-access
         generator_step_)
+    if size and isinstance(size[0], (tuple, list)):
+        size = size[0]
     return rand_ext_(size, seed, offset, dtype)
 
 
@@ -1159,9 +1314,6 @@ def rand_like_ext(input, *, dtype=None):
         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``
 
@@ -1192,7 +1344,7 @@ def randn_ext(*size, generator=None, dtype=None):
     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,
+        dtype (:class:`mindspore.dtype`, optional): Designated tensor dtype. If None,
             `mindspore.float32` will be applied. Default: ``None`` .
 
     Returns:
@@ -1200,7 +1352,7 @@ def randn_ext(*size, generator=None, dtype=None):
         the interval :math:`[0, 1)`.
 
     Raises:
-        ValueError: If `dtype` is not a `mstype.float_type` type.
+        ValueError: If `size` contains negative numbers.
 
     Supported Platforms:
         ``Ascend``
@@ -1214,6 +1366,8 @@ def randn_ext(*size, generator=None, dtype=None):
         generator = default_generator
     seed, offset = generator._step(  # pylint: disable=protected-access
         generator_step_)
+    if size and isinstance(size[0], (tuple, list)):
+        size = size[0]
     return randn_(size, seed, offset, dtype)
 
 
@@ -1237,9 +1391,6 @@ def randn_like_ext(input, *, dtype=None):
         Tensor, with the designated shape and dtype, filled with random numbers from the normal distribution on
         the interval :math:`[0, 1)`.
 
-    Raises:
-        ValueError: If `dtype` is not a `mstype.float_type` type.
-
     Supported Platforms:
         ``Ascend``
 
@@ -1256,8 +1407,10 @@ def randn_like_ext(input, *, dtype=None):
 
 
 @_function_forbid_reuse
-def randint_ext(low, high, size, *, generator=None, dtype=None):
+def randint_ext(*args, generator=None, dtype=None):
     r"""
+    randint(low=0, high, size, *, generator=None, dtype=None) -> Tensor
+
     Returns a new tensor filled with integer numbers from the uniform distribution over an interval :math:`[low, high)`
     based on the given shape and dtype.
 
@@ -1265,7 +1418,7 @@ def randint_ext(low, high, size, *, generator=None, dtype=None):
         This is an experimental API that is subject to change or deletion.
 
     Args:
-        low (int): the lower bound of the generated random number
+        low (int, optional): the lower bound of the generated random number. Default: ``0``.
         high (int): the upper bound of the generated random number
         size (Union[tuple(int), list(int)]): Shape of the new tensor, e.g. :math:`(2, 3)`.
 
@@ -1295,12 +1448,18 @@ def randint_ext(low, high, size, *, generator=None, dtype=None):
         generator = default_generator
     seed, offset = generator._step(  # pylint: disable=protected-access
         generator_step_)
-    return randint_(low, high, size, seed, offset, dtype)
+    args = list(args)
+    if len(args) == 2:
+        args = [0] + args
+    args += [seed, offset]
+    return randint_(*args, dtype=dtype)
 
 
 @_function_forbid_reuse
-def randint_like_ext(input, low, high, *, dtype=None):
+def randint_like_ext(*args, dtype=None):
     r"""
+    randint_like(input, low=0, high, *, dtype=None) -> Tensor
+
     Returns a new tensor filled with integer numbers from the uniform distribution over an interval :math:`[low, high)`
     based on the given dtype and shape of the input tensor.
 
@@ -1309,7 +1468,7 @@ def randint_like_ext(input, low, high, *, dtype=None):
 
     Args:
         input (Tensor): Input Tensor to specify the output shape and its default dtype.
-        low (int): the lower bound of the generated random number
+        low (int, optional): the lower bound of the generated random number. Default: ``0``.
         high (int): the upper bound of the generated random number
 
     Keyword Args:
@@ -1337,7 +1496,56 @@ def randint_like_ext(input, low, high, *, dtype=None):
     """
     seed, offset = default_generator._step(  # pylint: disable=protected-access
         generator_step_)
-    return randint_like_(input, low, high, seed, offset, dtype)
+    args = list(args)
+    if len(args) == 2:
+        args = [args[0], 0, args[1]]
+    args += [seed, offset]
+    return randint_like_(*args, dtype=dtype)
+
+
+@_function_forbid_reuse
+def random_(input, from_=0, to=None, *, generator=None):
+    r"""
+    Fill the input tensor with numbers sampled from a discrete uniform distribution
+    over an interval :math:`[low, high)`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): input tensor.
+        from_ (int, optional): the lower bound of the generated random number. Default: 0.
+        to (int, optional): the upper bound of the generated random number. By default it's the upper limit of
+            the input data type. Default: ``None``.
+
+    Keyword Args:
+        generator (:class:`mindspore.Generator`, optional): a pseudorandom number generator.
+            Default: ``None``, uses the default pseudorandom number generator.
+
+    Returns:
+        The input tensor.
+
+    Raises:
+        TypeError: If `from_` or `to` is not integer.
+        ValueError: If `from_` >= `to`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore import Tensor, ops
+        >>> a = Tensor([[2, 3, 4], [1, 2, 3]])
+        >>> from_ = 0
+        >>> to = 5
+        >>> print(ops.function.random_func.random_(a, from_, to).shape)
+        (2, 3)
+    """
+    if not generator:
+        generator = default_generator
+    seed, offset = generator._step(  # pylint: disable=protected-access
+        generator_step_)
+    return inplace_random_(input, from_, to, seed, offset)
 
 
 @_function_forbid_reuse
@@ -1575,10 +1783,11 @@ def randperm_ext(n, *, generator=None, dtype=mstype.int64):
     .. warning::
         - This is an experimental API that is subject to change or deletion.
 
-
     Args:
         n (Union[Tensor, int]): size of the permutation. int or Tensor with shape: () or (1,) and
             data type int64. The value of `n` must be greater than zero.
+
+    Keyword Args:
         generator (:class:`mindspore.Generator`, optional): a pseudorandom number generator.
             Default: ``None``, uses the default pseudorandom number generator.
         dtype (mindspore.dtype, optional): The type of output. Default: mstype.int64.
@@ -1672,7 +1881,8 @@ def multinomial(input, num_samples, replacement=True, seed=None):
 
     The polynomial distribution is a probability distribution that generalizes the binomial distribution formula to
     multiple states. In the polynomial distribution, each event has a fixed probability, and the sum of these
-    probabilities is 1. The purpose of the `mindspore.ops.multinomial` interface is to perform `num_samples` sampling
+    probabilities is 1. The purpose of the :func:`mindspore.ops.multinomial` interface
+    is to perform `num_samples` sampling
     on the input `input`, and the output tensor is the index of the input tensor for each sampling.
     The values in `input` represent the probability of selecting the corresponding index for each sampling.
 
@@ -1799,7 +2009,8 @@ def multinomial_ext(input, num_samples, replacement=False, *, generator=None):
 
     The polynomial distribution is a probability distribution that generalizes the binomial distribution formula to
     multiple states. In the polynomial distribution, each event has a fixed probability, and the sum of these
-    probabilities is 1. The purpose of the `mindspore.mint.multinomial` interface is to perform `num_samples` sampling
+    probabilities is 1. The purpose of the :func:`mindspore.mint.multinomial` interface
+    is to perform `num_samples` sampling
     on the input `input`, and the output tensor is the index of the input tensor for each sampling.
     The values in `input` represent the probability of selecting the corresponding index for each sampling.
 
@@ -1844,7 +2055,6 @@ def multinomial_ext(input, num_samples, replacement=False, *, generator=None):
 
     Raises:
         TypeError: If `input` is not a Tensor whose dtype is not in float16, float32, float64 or bfloat16.
-        , 或是shape为(1, 1)的Tensor
         TypeError: If `num_samples` is not an int, a Scalar of int
             or a Tensor with shape[1,] and only one int element.
         RuntimeError: If :math:`\text{num_samples} <= 0`.

mindspore/ops/function/sparse_unary_func.py

@@ -720,7 +720,7 @@ def csr_log(x: CSRTensor) -> CSRTensor:
         be affacted.
 
     Args:
-        x (CSRTensor): The value must be greater than 0.
+        x (CSRTensor): Input CSRTensor of any dimension. If the value is smaller than 0, return nan.
 
     Returns:
         CSRTensor, has the same shape and dtype as the `x`.

mindspore/ops/functional.py

@@ -20,8 +20,8 @@ from mindspore.common._register_for_tensor import tensor_operator_registry
 from mindspore.ops import _constants
 from mindspore.ops.function import *
 from mindspore.ops.function.array_func import chunk_ext, zero_
-from mindspore.ops.function.math_func import all, argmax_ext
-from mindspore.ops.function.random_func import uniform_ext
+from mindspore.ops.function.math_func import all, argmax_ext, float_power_ext, erfinv_, tanh_
+from mindspore.ops.function.random_func import random_, uniform_ext, uniform_, normal_
 from mindspore.ops import operations as P
 from mindspore.ops.operations import array_ops
 from mindspore.ops.operations._sequence_ops import TensorToTuple
@@ -33,12 +33,13 @@ from mindspore.ops.operations.nn_ops import AdaptiveMaxPool2D
 from mindspore.ops.operations.math_ops import Roll
 from mindspore.ops.composite.math_ops import mm
 from mindspore.ops.function.math_func import dot
+from mindspore.ops.function.array_func import new_empty
 from mindspore.ops import auto_generate
 from mindspore.ops.auto_generate import cast
 from mindspore.ops_generate.gen_ops_inner_prim import DtypeToEnum
 from mindspore.ops.operations.manually_defined.ops_def import scalar_div, scalar_mod, scalar_add, scalar_mul, \
     scalar_sub, scalar_gt, scalar_ge, scalar_le, scalar_lt, scalar_eq, scalar_floordiv, scalar_log, scalar_pow, \
-    scalar_uadd, scalar_usub, flash_attention_score
+    scalar_uadd, scalar_usub
 
 typeof = Primitive('typeof')
 hastype = Primitive('hastype')
@@ -191,7 +192,7 @@ setattr(tensor_operator_registry, 'index_select', index_select)
 setattr(tensor_operator_registry, 'flip', flip)
 setattr(tensor_operator_registry, 'fliplr', fliplr)
 setattr(tensor_operator_registry, 'flipud', flipud)
-setattr(tensor_operator_registry, 'float_power', float_power)
+setattr(tensor_operator_registry, 'float_power', float_power_ext)
 setattr(tensor_operator_registry, 'fmax', fmax)
 setattr(tensor_operator_registry, 'fmin', fmin)
 setattr(tensor_operator_registry, 'fmod', fmod)
@@ -204,6 +205,7 @@ setattr(tensor_operator_registry, 'bitwise_right_shift', bitwise_right_shift)
 setattr(tensor_operator_registry, 'ger', ger)
 setattr(tensor_operator_registry, 'reduce_max', P.ReduceMax)
 setattr(tensor_operator_registry, 'reduce_min', P.ReduceMin)
+setattr(tensor_operator_registry, 'random_', random_)
 setattr(tensor_operator_registry, 'random_categorical', random_categorical)
 setattr(tensor_operator_registry, 'mirror_pad', P.MirrorPad)
 setattr(tensor_operator_registry, 'minimum', minimum)
@@ -266,6 +268,7 @@ setattr(tensor_operator_registry, 'standard_normal', P.StandardNormal)
 setattr(tensor_operator_registry, 'sigmoid', sigmoid)
 setattr(tensor_operator_registry, 'median', Median)
 setattr(tensor_operator_registry, 'tanh', tanh)
+setattr(tensor_operator_registry, 'tanh_', tanh_)
 setattr(tensor_operator_registry, 'exp', exp)
 setattr(tensor_operator_registry, 'addbmm', addbmm)
 setattr(tensor_operator_registry, 'addmm', addmm)
@@ -281,15 +284,18 @@ setattr(tensor_operator_registry, 'bmm', bmm)
 setattr(tensor_operator_registry, 'conj', conj)
 setattr(tensor_operator_registry, 'cross', cross)
 setattr(tensor_operator_registry, 'erfinv', erfinv)
+setattr(tensor_operator_registry, 'erfinv_', erfinv_)
 setattr(tensor_operator_registry, 'less_equal', less_equal)
 setattr(tensor_operator_registry, 'lcm', lcm)
 setattr(tensor_operator_registry, 'ldexp', ldexp)
 setattr(tensor_operator_registry, 'clamp', clamp)
+setattr(tensor_operator_registry, 'clamp_', clamp_)
 setattr(tensor_operator_registry, 'fold', fold)
 setattr(tensor_operator_registry, 'unfold', unfold)
 setattr(tensor_operator_registry, 'diagonal', diagonal)
 setattr(tensor_operator_registry, 'diagonal_scatter', diagonal_scatter)
 setattr(tensor_operator_registry, 'index_add', index_add)
+setattr(tensor_operator_registry, 'index_add_', auto_generate.inplace_index_add_op)
 setattr(tensor_operator_registry, 'greater', greater)
 setattr(tensor_operator_registry, 'greater_equal', greater_equal)
 setattr(tensor_operator_registry, 'igamma', igamma)
@@ -300,6 +306,7 @@ setattr(tensor_operator_registry, 'qr', qr)
 setattr(tensor_operator_registry, 'ormqr', ormqr)
 setattr(tensor_operator_registry, 'masked_scatter', array_ops.MaskedScatter)
 setattr(tensor_operator_registry, 'index_put', array_ops.IndexPut)
+setattr(tensor_operator_registry, 'index_put_', auto_generate.index_put_)
 setattr(tensor_operator_registry, 'quantile', quantile)
 setattr(tensor_operator_registry, 'nanquantile', nanquantile)
 setattr(tensor_operator_registry, 'orgqr', orgqr)
@@ -333,6 +340,7 @@ setattr(tensor_operator_registry, 'reducesum', P.ReduceSum)
 setattr(tensor_operator_registry, 'tensor_slice', tensor_slice)
 setattr(tensor_operator_registry, 'select', select)
 setattr(tensor_operator_registry, 'uniform', uniform_ext)
+setattr(tensor_operator_registry, 'uniform_', uniform_)
 setattr(tensor_operator_registry, 'gather', gather)
 setattr(tensor_operator_registry, 'gather_d', gather_d)
 setattr(tensor_operator_registry, 'gather_elements', gather_elements)
@@ -345,6 +353,7 @@ setattr(tensor_operator_registry, 'log10', log10)
 setattr(tensor_operator_registry, 'log2', log2)
 setattr(tensor_operator_registry, 'lerp', lerp)
 setattr(tensor_operator_registry, 'floor', floor)
+setattr(tensor_operator_registry, 'floor_', auto_generate.floor_)
 setattr(tensor_operator_registry, 'floor_divide', floor_divide)
 # support sparse tensor operators
 setattr(tensor_operator_registry, 'csr_add', csr_add)
@@ -371,6 +380,7 @@ setattr(tensor_operator_registry, 'nanmedian', nanmedian)
 setattr(tensor_operator_registry, 'csr_to_coo', csr_to_coo)
 setattr(tensor_operator_registry, 'zeros', zeros)
 setattr(tensor_operator_registry, 'ones', ones)
+setattr(tensor_operator_registry, 'new_empty', new_empty)
 setattr(tensor_operator_registry, 'unsorted_segment_min', unsorted_segment_min)
 setattr(tensor_operator_registry, 'unsorted_segment_max', unsorted_segment_max)
 setattr(tensor_operator_registry, 'unsorted_segment_prod', unsorted_segment_prod)
@@ -382,6 +392,7 @@ setattr(tensor_operator_registry, 'tensor_scatter_min', tensor_scatter_min)
 setattr(tensor_operator_registry, 'tensor_scatter_max', tensor_scatter_max)
 setattr(tensor_operator_registry, 'tensor_scatter_sub', tensor_scatter_sub)
 setattr(tensor_operator_registry, 'tensor_scatter_add', tensor_scatter_add)
+setattr(tensor_operator_registry, 'inplace_scatter_add', auto_generate.inplace_scatter_add)
 setattr(tensor_operator_registry, 'slice_scatter', slice_scatter)
 setattr(tensor_operator_registry, 'select_scatter', select_scatter)
 setattr(tensor_operator_registry, 'bernoulli', bernoulli)
@@ -447,7 +458,8 @@ setattr(tensor_operator_registry, 'imag', imag)
 setattr(tensor_operator_registry, 'repeat_interleave', repeat_interleave)
 setattr(tensor_operator_registry, 'rad2deg', rad2deg)
 setattr(tensor_operator_registry, 'deg2rad', deg2rad)
-setattr(tensor_operator_registry, 'copy_', auto_generate.copy_ext)
+setattr(tensor_operator_registry, 'clone', auto_generate.clone)
+setattr(tensor_operator_registry, 'copy_', auto_generate.inplace_copy)
 setattr(tensor_operator_registry, 'add_', auto_generate.inplace_add_ext)
 setattr(tensor_operator_registry, 'adds_', auto_generate.inplace_adds_ext)
 setattr(tensor_operator_registry, 'copysign', copysign)
@@ -457,6 +469,7 @@ setattr(tensor_operator_registry, 'swapaxes', swapaxes)
 setattr(tensor_operator_registry, 'swapdims', swapdims)
 setattr(tensor_operator_registry, 'repeat_elements', repeat_elements)
 setattr(tensor_operator_registry, 'top_k', top_k)
+setattr(tensor_operator_registry, 'normal_', normal_)
 
 __all__ = [name for name in dir() if name[0] != "_"]
 __all__.remove('Primitive')